स्किटिट-लर्न (या किसी अन्य अजगर ढांचे) का उपयोग करके विभिन्न प्रकार के रजिस्टरों का संग्रह

Question

मैं प्रतिगमन कार्य को हल करने की कोशिश कर रहा हूं। मुझे पता चला कि 3 मॉडल डेटा के विभिन्न सबसेट के लिए अच्छी तरह से काम कर रहे हैं: लैस्लोआरएस, एसवीआर और ग्रेडिएंट ट्री बोइंग। मैंने देखा कि जब मैं इन सभी 3 मॉडलों का उपयोग करके भविष्यवाणियाँ करता हूँ और फिर '3 ट्रू आउटपुट' की तालिका बनाता हूँ और अपने 3 मॉडलों के आउटपुट को देखता हूँ, तो हर बार कम से कम एक मॉडल वास्तव में वास्तविक आउटपुट के करीब होता है, हालाँकि 2 अन्य अपेक्षाकृत दूर हो सकता है।

जब मैं न्यूनतम संभावित त्रुटि की गणना करता हूं (यदि मैं प्रत्येक परीक्षण उदाहरण के लिए 'सर्वश्रेष्ठ' पूर्वसूचक से भविष्यवाणी करता हूं) तो मुझे एक त्रुटि मिलती है जो अकेले किसी भी मॉडल की त्रुटि से बहुत छोटी है। इसलिए मैंने इन 3 अलग-अलग मॉडलों से भविष्यवाणियों को किसी तरह के संयोजन में संयोजित करने की कोशिश करने के बारे में सोचा। सवाल है, यह कैसे ठीक से करना है? मेरे सभी 3 मॉडल का निर्माण और स्किकिट-लर्न का उपयोग करके ट्यून किया गया है, क्या यह किसी प्रकार की विधि प्रदान करता है जिसका उपयोग मॉडल को पहनावा में पैक करने के लिए किया जा सकता है? यहां समस्या यह है कि मैं सभी तीन मॉडलों से केवल औसत भविष्यवाणियां नहीं करना चाहता हूं, मैं ऐसा वजन के साथ करना चाहता हूं, जहां विशिष्ट उदाहरण के गुणों के आधार पर वजन निर्धारित किया जाना चाहिए।

यहां तक ​​कि अगर scikit-learn इस तरह की कार्यक्षमता प्रदान नहीं करता है, तो यह अच्छा होगा यदि कोई जानता है कि संपत्ति इस कार्य को कैसे संबोधित करती है - डेटा में प्रत्येक उदाहरण के लिए प्रत्येक मॉडल के भार का पता लगाना। मुझे लगता है कि यह इन सभी 3 मॉडलों के शीर्ष पर निर्मित एक अलग रजिस्ट्रार द्वारा किया जा सकता है, जो कि प्रत्येक 3 मॉडल के लिए आउटपुट इष्टतम भार की कोशिश करेगा, लेकिन मुझे यकीन नहीं है कि यह ऐसा करने का सबसे अच्छा तरीका है।

Answer 1

वास्तव में, scikit-learnइस तरह की कार्यक्षमता प्रदान करता है, हालांकि इसे लागू करने के लिए थोड़ा मुश्किल हो सकता है। इस तरह के तीन मॉडलों के शीर्ष पर निर्मित इस तरह के एक औसत प्रतिगमन का एक पूरा कार्य उदाहरण है। सबसे पहले, आइए सभी आवश्यक पैकेजों को आयात करें:

from sklearn.base import TransformerMixin
from sklearn.datasets import make_regression
from sklearn.pipeline import Pipeline, FeatureUnion
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.neighbors import KNeighborsRegressor
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.linear_model import LinearRegression, Ridge

फिर, हमें अपने तीन प्रतिगामी मॉडल को ट्रांसफार्मर में बदलने की आवश्यकता है। यह हमें एक प्रयोग सुविधा वेक्टर में उनकी भविष्यवाणियों को मर्ज करने की अनुमति देगा FeatureUnion:

class RidgeTransformer(Ridge, TransformerMixin):

    def transform(self, X, *_):
        return self.predict(X)


class RandomForestTransformer(RandomForestRegressor, TransformerMixin):

    def transform(self, X, *_):
        return self.predict(X)


class KNeighborsTransformer(KNeighborsRegressor, TransformerMixin):

    def transform(self, X, *_):
        return self.predict(X)

अब, हमारे फ्रेंकस्टीन मॉडल के लिए एक बिल्डर फ़ंक्शन को परिभाषित करते हैं:

def build_model():
    ridge_transformer = Pipeline(steps=[
        ('scaler', StandardScaler()),
        ('poly_feats', PolynomialFeatures()),
        ('ridge', RidgeTransformer())
    ])

    pred_union = FeatureUnion(
        transformer_list=[
            ('ridge', ridge_transformer),
            ('rand_forest', RandomForestTransformer()),
            ('knn', KNeighborsTransformer())
        ],
        n_jobs=2
    )

    model = Pipeline(steps=[
        ('pred_union', pred_union),
        ('lin_regr', LinearRegression())
    ])

    return model

अंत में, आइए मॉडल फिट करें:

print('Build and fit a model...')

model = build_model()

X, y = make_regression(n_features=10, n_targets=2)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

model.fit(X_train, y_train)
score = model.score(X_test, y_test)

print('Done. Score:', score)

आउटपुट:

Build and fit a model...
Done. Score: 0.9600413867438636

ऐसे में चीजों को उलझाना क्यों परेशान करता है? ठीक है, यह दृष्टिकोण हमें मानक scikit-learnमॉड्यूल जैसे कि GridSearchCVया का उपयोग करके मॉडल हाइपरपरमेटर्स को अनुकूलित करने की अनुमति देता है RandomizedSearchCV। इसके अलावा, अब डिस्क से पूर्व प्रशिक्षित मॉडल को आसानी से सहेजना और लोड करना संभव है।

Comments

इस दृष्टिकोण का उपयोग करते समय, क्या प्रत्येक एलगो के कब / किस अंश का उपयोग करने के लिए एक सरल तरीका है?

— डेविड हैगन

शायद परिणामी रैखिक मॉडल के गुणांक को देखते हुए ( model.named_steps['lin_regr'].coef_) आपको कुछ अंतर्दृष्टि देगा कि एक पहनावा में प्रत्येक मॉडल अंतिम समाधान में कितना योगदान देता है।

— 12

@constt क्या आपको अपने आधार मॉडल में cross_val_predict का उपयोग करने की आवश्यकता नहीं होगी? ऐसा लगता है कि आपके शीर्ष-स्तरीय मॉडल को आपके आधार मॉडल से एक ओवरोप्टिमिस्टिक सिग्नल प्राप्त होगा क्योंकि यह वर्तमान में लागू है।

— ब्रायन बिएन

यह केवल थोड़े सबूत-की-अवधारणा उदाहरण है, मैंने यहां एक मॉडल चयन को संबोधित नहीं किया। मुझे लगता है कि इस तरह के मॉडल को एक पूरे के रूप में अनुकूलित किया जाना चाहिए, अर्थात, क्रॉस-वैध दृष्टिकोण का उपयोग करके सभी अंतर्निहित मॉडल के हाइपर-मापदंडों को अनुकूलित करना।

— constt

अगर हम n_targets = 1 डालते हैं तो X, y = make_regression(n_features=10, n_targets=1)यह डायमेंशन एरर देता है। किसी को भी समझा सकता है कि क्या करना है?

— मोहित यादव

Answer 2

ठीक है, गुग्लिंग पर कुछ समय बिताने के बाद मुझे पता चला कि मैं स्किट-लर्न के साथ भी अजगर में वेटिंग कैसे कर सकता हूं। नीचे पर विचार करें:

मैं अपने प्रतिगमन मॉडल का एक सेट (जैसा कि SVR, LassoLars और GradientBoostingRegressor का उल्लेख करता हूं) को प्रशिक्षित करता हूं। फिर मैं उन सभी को प्रशिक्षण डेटा पर चलाता हूं (वही डेटा जो इन 3 रजिस्टरों में से प्रत्येक के प्रशिक्षण के लिए उपयोग किया गया था)। मुझे अपने प्रत्येक एल्गोरिदम के साथ उदाहरणों के लिए भविष्यवाणियां मिलती हैं और इन 3 परिणामों को कॉलम 'प्रेडिक्टेडएसवीआर', 'प्रीडिस्डलेस्सो' और 'प्रेडिक्टेडजीबीआर' के साथ पंडों के डेटाफ्रेम में सहेजा जाता है। और मैं इस डेटाफ्रेन में अंतिम कॉलम जोड़ता हूं, जिसे मैं 'प्रेडिक्टेड' कहता हूं, जो एक वास्तविक भविष्यवाणी मूल्य है।

तब मैं इस नई डेटाफ्रेम पर एक रेखीय प्रतिगमन को प्रशिक्षित करता हूं:

 #df - dataframe with results of 3 regressors and true output

 from sklearn linear_model
 stacker= linear_model.LinearRegression()
 stacker.fit(df[['predictedSVR', 'predictedLASSO', 'predictedGBR']], df['predicted'])

इसलिए जब मैं नए उदाहरण के लिए एक भविष्यवाणी करना चाहता हूं तो मैं अपने 3 रजिस्टरों में से प्रत्येक को अलग से चलाता हूं और फिर करता हूं:

 stacker.predict() 

मेरे 3 रजिस्टरों के आउटपुट पर। और एक परिणाम मिलता है।

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

अगर किसी के पास मौजूदा उदाहरण की सुविधाओं का उपयोग करके स्टैकिंग (वेटिंग) करने का कोई विचार है, तो उन्हें सुनना अच्छा होगा।

Comments

वाह, मुझे यह दृष्टिकोण बहुत पसंद है! लेकिन आपने मॉडल के LinearRegression()बजाय क्यों इस्तेमाल किया LogisticRegression()?

— harrison4

@ harrison4 क्योंकि मैं प्रतिगमन कर रहा था, वर्गीकरण कार्य नहीं? इसलिए मैं प्रत्येक मॉडल से 'वेट' आउटपुट लेना चाहता था। वैसे भी, यह एक बुरा दृष्टिकोण है, यहाँ अच्छा वर्णन किया गया है: stackoverflow.com/a/35170149/3633250

— मकिसिम खितोविच

हाँ, क्षमा करें, आप सही हैं! लिंक शेयर करने के लिए धन्यवाद!

— harrison4

Answer 3

यदि आपके डेटा में स्पष्ट उपसमूह हैं, तो आप k- साधन की तरह क्लस्टरिंग एल्गोरिथ्म चला सकते हैं और फिर प्रत्येक क्लासिफायर को उस क्लस्टर के साथ जोड़ सकते हैं, जिस पर वह अच्छा प्रदर्शन करता है। जब एक नया डेटा बिंदु आता है, तो यह निर्धारित करें कि यह किस क्लस्टर में है और संबंधित क्लासिफायर को चलाता है।

आप प्रत्येक क्लासिफ़ायर के लिए भार का एक सेट प्राप्त करने और सभी क्लासिफायरफ़ाइलों के रैखिक संयोजन का उपयोग करने की भविष्यवाणी करने के लिए सेंट्रोइड्स से व्युत्क्रम दूरी का उपयोग भी कर सकते हैं।

Comments

मैंने पाया कि इस स्टैगी का एक पेपर (कुछ इसी तरह के विचारों की तुलना के साथ) परीक्षण किया गया: पेपर

— एंथनीबेल

दिलचस्प विचार, हालांकि इसे लागू करने के लिए बहुत सारे काम की आवश्यकता होती है। कागज के लिए धन्यवाद!

— मक्सिम खितोविच

Answer 4

मैं निम्नलिखित करके एक प्रकार का वेटिंग पूरा करता हूं, एक बार जब आपके सभी मॉडल पूरी तरह से प्रशिक्षित हो जाते हैं और अच्छा प्रदर्शन करते हैं:

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

आप कुछ समय में प्रतिशत सही का माप लेकर अपने पहनावे को और भी बेहतर बना सकते हैं। एक बार जब आपके पास एक बड़ा, नया डेटा सेट स्कोर हो जाता है, तो आप 0.1 के चरणों में थ्रेसहोल्ड को प्लॉट कर सकते हैं, उदाहरण के लिए, प्रतिशत के विरुद्ध प्रतिशत सही, अगर स्कोर करने के लिए उस सीमा का उपयोग करने के बारे में, तो आपको यह अनुमान लगाने के लिए कि 95% सही क्या है कक्षा 1 के लिए, और इसी तरह। आप नए डेटा के आने और बहाव के ट्रैक को बनाए रखने के लिए परीक्षण सेट और एफ 1 स्कोर को अपडेट करते रह सकते हैं, जब थ्रेसहोल्ड या सटीकता गिरती है तो मॉडल का पुनर्निर्माण करते हैं।

Comments

यह दिलचस्प है, लेकिन यह केवल वर्गीकरण कार्यों के लिए काम करता है, जहां तक ​​मैं देखता हूं, जबकि मैं प्रतिगमन कार्य को हल करने की कोशिश कर रहा हूं। इस प्रकार मैं F1 स्कोर की गणना नहीं कर सकता।

— मिकीसिम खितोविच