कैलिब्रेटेड क्लासिफायरसीवी प्रत्यक्ष वर्गीकरण को कम क्यों करता है?

Question

मैंने देखा कि sklearn का नया CalibratedClassifierCV सीधे base_estimator को कम प्रदर्शन करता है जब base_estimatorGradientBoostingClassifer है, (मैंने अन्य क्लासिफायरों का परीक्षण नहीं किया है)। दिलचस्प बात यह है कि अगर make_classification के मापदंडों हैं:

n_features = 10 
n_informative = 3 
n_classes = 2 

तो CalibratedClassifierCV मामूली outperformer हो रहा है (लॉग नुकसान मूल्यांकन)।

from sklearn.datasets import make_classification 
from sklearn import ensemble 
from sklearn.calibration import CalibratedClassifierCV 
from sklearn.metrics import log_loss 
from sklearn import cross_validation 
# Build a classification task using 3 informative features 

X, y = make_classification(n_samples=1000, 
          n_features=100, 
          n_informative=30, 
          n_redundant=0, 
          n_repeated=0, 
          n_classes=9, 
          random_state=0, 
          shuffle=False) 

skf = cross_validation.StratifiedShuffleSplit(y, 5) 

for train, test in skf: 

    X_train, X_test = X[train], X[test] 
    y_train, y_test = y[train], y[test] 

    clf = ensemble.GradientBoostingClassifier(n_estimators=100) 
    clf_cv = CalibratedClassifierCV(clf, cv=3, method='isotonic') 
    clf_cv.fit(X_train, y_train) 
    probas_cv = clf_cv.predict_proba(X_test) 
    cv_score = log_loss(y_test, probas_cv) 

    clf = ensemble.GradientBoostingClassifier(n_estimators=100) 
    clf.fit(X_train, y_train) 
    probas = clf.predict_proba(X_test) 
    clf_score = log_loss(y_test, probas) 

    print 'calibrated score:', cv_score 
    print 'direct clf score:', clf_score 
    print 

एक रन झुकेंगे:

शायद मैं के बारे में कैसे CalibratedClassifierCV कुछ याद कर रहा हूँ

हालांकि, के अंतर्गत निम्नलिखित वर्गीकरण डेटा सेट CalibratedClassifierCV आम तौर पर underperformer हो रहा है काम करता है, या इसे सही तरीके से उपयोग नहीं कर रहा हूं, लेकिन मैं इस धारणा के तहत था कि CalibratedClassifierCV पर क्लासिफायर पास करने वाले कुछ भी परिणामस्वरूप रिश्तेदार रिश्तेदार अकेले base_estimator पर।

क्या कोई इस कम प्रदर्शन को समझा सकता है?

Answer 1

संभावना अंशांकन ही पार सत्यापन गुना प्रति एक कैलिब्रेटेड वर्गीकारक (इस मामले StratifiedKFold का उपयोग करने में) की आवश्यकता है, इसलिए CalibratedClassifierCV गाड़ियों, और प्रत्येक वर्गीकारक से भविष्यवाणी की संभावनाओं का मतलब होता है जब आप() predict_proba कहते हैं। इससे प्रभाव की व्याख्या हो सकती है।

मेरी परिकल्पना यह है कि यदि प्रशिक्षण सेट सुविधाओं और वर्गों की संख्या के संबंध में छोटा है, तो प्रत्येक उप-वर्गीकरण के लिए कम प्रशिक्षण सेट प्रदर्शन को प्रभावित करता है और ensembling इसके लिए नहीं बनता है (या इसे और भी खराब बनाता है) । इसके अलावा GradientBoostingClassifier शुरुआत से पहले से ही बहुत अच्छी संभावना अनुमान प्रदान कर सकता है क्योंकि इसके हानि फ़ंक्शन को संभाव्यता अनुमान के लिए अनुकूलित किया गया है।

अगर वह सही है, ensembling classifiers CalibratedClassifierCV के रूप में लेकिन अंशांकन के बिना उसी तरह एक वर्गीकारक से भी बदतर होना चाहिए। इसके अलावा, कैलिब्रेशन के लिए बड़ी संख्या में फोल्ड का उपयोग करते समय प्रभाव गायब हो जाना चाहिए।

कि परीक्षण करने के लिए, मैं परतों की संख्या में वृद्धि करने के लिए अपनी स्क्रिप्ट बढ़ाया और अंशांकन के बिना ensembled वर्गीकारक में शामिल हैं, और मैं अपने भविष्यवाणियों की पुष्टि करने में सक्षम था। एक 10 गुना कैलिब्रेटेड वर्गीकारक हमेशा एक वर्गीकारक की तुलना में बेहतर प्रदर्शन किया और गैर-अंशांकित कलाकारों की टुकड़ी में काफी बदतर था। मेरे समय में, 3 गुना कैलिब्रेटेड वर्गीकारक भी वास्तव में एक वर्गीकारक से खराब प्रदर्शन नहीं किया, इसलिए यह भी एक अस्थिर प्रभाव हो सकता है।

यह मेरा प्रयोग का कोड है: ये वही डाटासेट के बारे में विस्तृत परिणाम हैं

import numpy as np 
from sklearn.datasets import make_classification 
from sklearn import ensemble 
from sklearn.calibration import CalibratedClassifierCV 
from sklearn.metrics import log_loss 
from sklearn import cross_validation 

X, y = make_classification(n_samples=1000, 
          n_features=100, 
          n_informative=30, 
          n_redundant=0, 
          n_repeated=0, 
          n_classes=9, 
          random_state=0, 
          shuffle=False) 

skf = cross_validation.StratifiedShuffleSplit(y, 5) 

for train, test in skf: 

    X_train, X_test = X[train], X[test] 
    y_train, y_test = y[train], y[test] 

    clf = ensemble.GradientBoostingClassifier(n_estimators=100) 
    clf_cv = CalibratedClassifierCV(clf, cv=3, method='isotonic') 
    clf_cv.fit(X_train, y_train) 
    probas_cv = clf_cv.predict_proba(X_test) 
    cv_score = log_loss(y_test, probas_cv) 
    print 'calibrated score (3-fold):', cv_score 


    clf = ensemble.GradientBoostingClassifier(n_estimators=100) 
    clf_cv = CalibratedClassifierCV(clf, cv=10, method='isotonic') 
    clf_cv.fit(X_train, y_train) 
    probas_cv = clf_cv.predict_proba(X_test) 
    cv_score = log_loss(y_test, probas_cv) 
    print 'calibrated score (10-fold:)', cv_score 

    #Train 3 classifiers and take average probability 
    skf2 = cross_validation.StratifiedKFold(y_test, 3) 
    probas_list = [] 
    for sub_train, sub_test in skf2: 
     X_sub_train, X_sub_test = X_train[sub_train], X_train[sub_test] 
     y_sub_train, y_sub_test = y_train[sub_train], y_train[sub_test] 
     clf = ensemble.GradientBoostingClassifier(n_estimators=100) 
     clf.fit(X_sub_train, y_sub_train) 
     probas_list.append(clf.predict_proba(X_test)) 
    probas = np.mean(probas_list, axis=0) 
    clf_ensemble_score = log_loss(y_test, probas) 
    print 'uncalibrated ensemble clf (3-fold) score:', clf_ensemble_score 

    clf = ensemble.GradientBoostingClassifier(n_estimators=100) 
    clf.fit(X_train, y_train) 
    probas = clf.predict_proba(X_test) 
    score = log_loss(y_test, probas) 
    print 'direct clf score:', score 
    print 

Answer 2

एक अंशांकन वर्गीकरण का उपयोग करने की बात एक संभावित भविष्यवाणी के साथ आना है जो एक सामान्य वर्गीकृत की तुलना में थोड़ा आसान व्यवहार करता है। यह आपके मूल अनुमानक के प्रदर्शन को बढ़ाने के लिए नहीं है।

इसलिए कोई गारंटी नहीं है कि संभावनाएं या लॉग-हानि वही होगी (समान पड़ोस, लेकिन समान नहीं)। लेकिन अगर आपने अपने नमूने + संभावनाओं को प्लॉट किया है तो आप शायद एक बहुत अच्छा वितरण देखेंगे।

अधिकतर संरक्षित किए जाने वाले निर्णय निर्णय सीमा (0.5) के ऊपर और नीचे # नमूने होंगे।

Answer 3

वहाँ isotonic प्रतिगमन विधि के साथ मुद्दों (और में इसके कार्यान्वयन के एक जोड़े हैं sklearn) जो इसे अंशांकन के लिए एक उपमहाद्वीप पसंद बनाते हैं।

विशेष रूप से:

1) यह अंशांकन समारोह के लिए एक सुचारू रूप से अलग-अलग वक्र के बजाय एक piecewise निरंतर समारोह फिट बैठता है।

2) क्रॉस-वैलिडेशन मॉडल/कैलिब्रेशंस के परिणाम को प्रत्येक गुना से प्राप्त करता है। हालांकि, उनमें से प्रत्येक परिणाम अभी भी संबंधित फ़ोल्डरों पर फिट और कैलिब्रेटेड है।

अक्सर, बेहतर विकल्प SplineCalibratedClassifierCV कक्षा ML-insights पैकेज में है (अस्वीकरण: मैं उस पैकेज का लेखक हूं)। पैकेज के लिए जिथब रेपो here है।

यह निम्न लाभ हैं:

1) यह बल्कि एक piecewise निरंतर समारोह की तुलना में एक घन चौरसाई पट्टी फिट बैठता है।

2) यह अंशांकन के लिए पूरे (क्रॉस-मान्य) उत्तर सेट का उपयोग करता है और पूर्ण डेटा सेट पर आधार मॉडल को रीफिट करता है। इस प्रकार, अंशांकन समारोह और आधार मॉडल दोनों को पूर्ण डेटा सेट पर प्रभावी ढंग से प्रशिक्षित किया जाता है।

आप here और here तुलना के उदाहरण देख सकते हैं।

पहले उदाहरण से, यहां एक ग्राफ है जो एक प्रशिक्षण सेट (लाल बिंदु), स्वतंत्र परीक्षण सेट (हरे + संकेत) की पिन की संभावनाओं को दिखाता है, और एमएल-अंतर्दृष्टि स्पलीन विधि (नीली रेखा) द्वारा गणना की गई अंशांकन) और आइसोटोनिक-स्लेलेन विधि (ग्रे डॉट्स/लाइन)।

मैं तरीकों की तुलना करने के लिए अपने कोड को संशोधित किया है (और उदाहरण की संख्या बढ़ी)। यह दर्शाता है कि स्पलीन दृष्टिकोण टाइपिकल बेहतर प्रदर्शन करता है (जैसा कि मैंने ऊपर से जुड़े उदाहरणों को किया है)।

import numpy as np from sklearn.datasets import make_classification from sklearn import ensemble from sklearn.calibration import CalibratedClassifierCV from sklearn.metrics import log_loss from sklearn import cross_validation import ml_insights as mli

X, y = make_classification(n_samples=10000, n_features=100, n_informative=30, n_redundant=0, n_repeated=0, n_classes=9, random_state=0, shuffle=False)

skf = cross_validation.StratifiedShuffleSplit(y, 5)

for train, test in skf:

:

संहिता (आप pip install ml_insights पहले करना होगा):

यहाँ कोड और परिणाम है

X_train, X_test = X[train], X[test] 
y_train, y_test = y[train], y[test] 

clf = ensemble.GradientBoostingClassifier(n_estimators=100)  
clf_cv_mli = mli.SplineCalibratedClassifierCV(clf, cv=3) 
clf_cv_mli.fit(X_train, y_train) 
probas_cv_mli = clf_cv_mli.predict_proba(X_test) 
cv_score_mli = log_loss(y_test, probas_cv_mli) 

clf = ensemble.GradientBoostingClassifier(n_estimators=100)  
clf_cv = CalibratedClassifierCV(clf, cv=3, method='isotonic') 
clf_cv.fit(X_train, y_train) 
probas_cv = clf_cv.predict_proba(X_test) 
cv_score = log_loss(y_test, probas_cv) 

clf = ensemble.GradientBoostingClassifier(n_estimators=100) 
clf.fit(X_train, y_train) 
probas = clf.predict_proba(X_test) 
clf_score = log_loss(y_test, probas) 

clf = ensemble.GradientBoostingClassifier(n_estimators=100)  
clf_cv_mli = mli.SplineCalibratedClassifierCV(clf, cv=10) 
clf_cv_mli.fit(X_train, y_train) 
probas_cv_mli = clf_cv_mli.predict_proba(X_test) 
cv_score_mli_10 = log_loss(y_test, probas_cv_mli) 

clf = ensemble.GradientBoostingClassifier(n_estimators=100)  
clf_cv = CalibratedClassifierCV(clf, cv=10, method='isotonic') 
clf_cv.fit(X_train, y_train) 
probas_cv = clf_cv.predict_proba(X_test) 
cv_score_10 = log_loss(y_test, probas_cv) 

print('\nuncalibrated score: {}'.format(clf_score)) 
print('\ncalibrated score isotonic-sklearn (3-fold): {}'.format(cv_score)) 
print('calibrated score mli (3-fold): {}'.format(cv_score_mli)) 
print('\ncalibrated score isotonic-sklearn (10-fold): {}'.format(cv_score_10)) 
print('calibrated score mli (10-fold): {}\n'.format(cv_score_mli_10))` 

परिणाम

uncalibrated score: 1.4475396740876696

calibrated score isotonic-sklearn (3-fold): 1.465140552847886 calibrated score mli (3-fold): 1.3651638065446683

calibrated score isotonic-sklearn (10-fold): 1.4158622673607426 calibrated score mli (10-fold): 1.3620771116522705

uncalibrated score: 1.5097320476479625

calibrated score isotonic-sklearn (3-fold): 1.5189534673089442 calibrated score mli (3-fold): 1.4386253950100405

calibrated score isotonic-sklearn (10-fold): 1.4976505139437257 calibrated score mli (10-fold): 1.4408912879989917

uncalibrated score: 1.4654527691892194

calibrated score isotonic-sklearn (3-fold): 1.493355643575107 calibrated score mli (3-fold): 1.388789694535648

calibrated score isotonic-sklearn (10-fold): 1.419760490609242 calibrated score mli (10-fold): 1.3830851694161692

uncalibrated score: 1.5163851866969407

calibrated score isotonic-sklearn (3-fold): 1.5532628847926322 calibrated score mli (3-fold): 1.459797287154743

calibrated score isotonic-sklearn (10-fold): 1.4748100659449732 calibrated score mli (10-fold): 1.4620173012979816

uncalibrated score: 1.4760935523959617

calibrated score isotonic-sklearn (3-fold): 1.469434735152088 calibrated score mli (3-fold): 1.402024502986732

calibrated score isotonic-sklearn (10-fold): 1.4702032019673137 calibrated score mli (10-fold): 1.3983943648572212