Evalml: स्टैक्ड पहनावा खराब प्रदर्शन कर रहा है

@dancuarini मैंने इसे स्थानीय रूप से पुन: पेश करने की कोशिश की लेकिन सक्षम नहीं था; AutoMLSearch चलाने से पहले अतिरिक्त चरणों के कारण हो सकता है (उदा: डेटा स्प्लिट आकार, ड्रॉपिंग कॉलम)। चलो समस्या विन्यास के बारे में बात करते हैं!

यहां मैंने स्थानीय रूप से चलाने की कोशिश की है:

from evalml.automl import AutoMLSearch
import pandas as pd
import woodwork as ww
from evalml.automl.callbacks import raise_error_callback

happiness_data_set = pd.read_csv("Happiness Data Full Set.csv")
y = happiness_data_set['Happiness']
X = happiness_data_set.drop(['Happiness'], axis=1)
# display(X.head())

X = ww.DataTable(X)
X_train, X_holdout, y_train, y_holdout = evalml.preprocessing.split_data(X, y, problem_type='regression', test_size=0.2, random_seed=0)
# print(X.types)

automl = AutoMLSearch(X, y, problem_type="regression", objective="MAE", error_callback=raise_error_callback, max_batches=20, ensembling=True)
automl.search()

इसका परिणाम निम्नलिखित रैंकिंग में होता है:

वर्तमान प्रगति: स्थानीय स्तर पर रिप्रो में सक्षम नहीं होने के बारे में रेप्रो - इंग और अगले चरणों के बारे में रहेगा ।

@ एंजेला 97lin रुको, क्या आप वाकई

पुनरुत्पादक साझा करने के लिए धन्यवाद :)

@dsherry हालांकि यह थोड़ा संदेहास्पद है कि स्टैक्ड

@ एंजेला 97 लिन आह हाँ समझ गया! मैंने आपको कुछ नोट्स भेजे हैं।

मुझे लगता है कि कोई भी सबूत है कि हमारे पहनावा हमेशा शीर्ष के करीब नहीं होते हैं, एक समस्या है।

इसमें थोड़ा और खोदो। मुझे लगता है कि कुछ संभावित कारण हैं कि एनसेंबलर इस डेटा सेट के साथ खराब प्रदर्शन क्यों करता है:

1. डेटासेट वास्तव में छोटा है, और हमारी वर्तमान डेटा विभाजन रणनीति का अर्थ है कि एनसेम्बलर को डेटा के एक बहुत छोटे उपसमुच्चय के साथ प्रदान किया जाता है और मान्य किया जाता है। अभी, यदि हम एक स्टैक्ड एनसेम्बलर को प्रशिक्षित करना चाहते हैं, तो हम एनसेम्बलर को प्रशिक्षित करने के लिए कुछ डेटा ( ensembling_indices साथ पहचाने गए) को विभाजित करते हैं। यह धातु सीखने वाले को उसी डेटा पर प्रशिक्षण के माध्यम से एनसेंबलर को ओवरफिट करने से रोकने के लिए है जिस पर इनपुट पाइपलाइन पहले से ही प्रशिक्षित थे। फिर हम एक सीवी स्प्लिट करते हैं, और डेटा को ensembling_indices से विभाजित करते हैं। 128 पंक्तियों के इस डेटासेट के लिए, हम क्रमशः 17 और 8 पंक्तियों पर प्रशिक्षण और सत्यापन करते हैं। मैंने यह चर्चा करने के लिए #2144 दायर किया कि क्या हम यह अतिरिक्त सीवी विभाजन करना चाहते हैं।

2. हमारे एनसेंबलर का निर्माण वर्तमान में पाए गए प्रत्येक मॉडल परिवार की सर्वश्रेष्ठ पाइपलाइन को लेकर और स्टैक्ड एनसेंबलर के लिए इनपुट पाइपलाइन के रूप में उपयोग करके किया जाता है। हालांकि, अगर कुछ इनपुट पाइपलाइन काफी खराब प्रदर्शन करते हैं, तो स्टैक्ड एन्सेम्बलर एक उच्च-प्रदर्शन वाली व्यक्तिगत पाइपलाइन के साथ-साथ प्रदर्शन नहीं कर सकता है।

उदाहरण के लिए, यह अंतिम रैंकिंग तालिका है:

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

इसके लिए रेप्रो कोड यहां दिया गया है:

उपर से:

import pandas as pd
import woodwork as ww
happiness_data_set = pd.read_csv("Happiness Data Full Set.csv")
y = happiness_data_set['Happiness']
X = happiness_data_set.drop(['Happiness'], axis=1)

X = ww.DataTable(X)
X_train, X_holdout, y_train, y_holdout = evalml.preprocessing.split_data(X, y, problem_type='regression', test_size=0.25, random_seed=0)

automl = AutoMLSearch(X, y, problem_type="regression", objective="MAE", error_callback=raise_error_callback, max_batches=10, ensembling=True)
automl.search()

import woodwork as ww
from evalml.automl.engine import train_and_score_pipeline
from evalml.automl.engine.engine_base import JobLogger

# Get the pipelines fed into the ensemble but only use the ones better than the stacked ensemble
input_pipelines = []
input_info = automl._automl_algorithm._best_pipeline_info
from evalml.model_family import ModelFamily

trimmed = dict()
trimmed.update({ModelFamily.RANDOM_FOREST: input_info[ModelFamily.RANDOM_FOREST]})
trimmed.update({ModelFamily.XGBOOST: input_info[ModelFamily.XGBOOST]})
trimmed.update({ModelFamily.DECISION_TREE: input_info[ModelFamily.EXTRA_TREES]})

for pipeline_dict in trimmed.values():
    pipeline_class = pipeline_dict['pipeline_class']
    pipeline_params = pipeline_dict['parameters']
    input_pipelines.append(pipeline_class(parameters=automl._automl_algorithm._transform_parameters(pipeline_class, pipeline_params),
                                                      random_seed=automl._automl_algorithm.random_seed))
ensemble_pipeline = _make_stacked_ensemble_pipeline(input_pipelines, "regression")
X_train = X.iloc[automl.ensembling_indices]
y_train = ww.DataColumn(y.iloc[automl.ensembling_indices])
train_and_score_pipeline(ensemble_pipeline, automl.automl_config, X_train, y_train, JobLogger())

इन तीन मॉडल परिवारों का उपयोग करके, हमें ~ 0.22 का एमएई स्कोर मिलता है, जो कि किसी भी व्यक्तिगत पाइपलाइन से काफी बेहतर है।

#output of train_and_score_pipeline(ensemble_pipeline, automl.automl_config, X_train, y_train, JobLogger())
{'scores': {'cv_data': [{'all_objective_scores': OrderedDict([('MAE',
                  0.22281276417465426),
                 ('ExpVariance', 0.9578811127332543),
                 ('MaxError', 0.3858477236606914),
                 ('MedianAE', 0.2790362808260225),
                 ('MSE', 0.0642654425375983),
                 ('R2', 0.9152119239698017),
                 ('Root Mean Squared Error', 0.2535062968401343),
                 ('# Training', 17),
                 ('# Validation', 9)]),
    'mean_cv_score': 0.22281276417465426,
    'binary_classification_threshold': None}],
  'training_time': 9.944366216659546,
  'cv_scores': 0    0.222813
  dtype: float64,
  'cv_score_mean': 0.22281276417465426},
 'pipeline': TemplatedPipeline(parameters={'Stacked Ensemble Regressor':{'input_pipelines': [GeneratedPipeline(parameters={'Imputer':{'categorical_impute_strategy': 'most_frequent', 'numeric_impute_strategy': 'most_frequent', 'categorical_fill_value': None, 'numeric_fill_value': None}, 'One Hot Encoder':{'top_n': 10, 'features_to_encode': None, 'categories': None, 'drop': 'if_binary', 'handle_unknown': 'ignore', 'handle_missing': 'error'}, 'Random Forest Regressor':{'n_estimators': 184, 'max_depth': 25, 'n_jobs': -1},}), GeneratedPipeline(parameters={'Imputer':{'categorical_impute_strategy': 'most_frequent', 'numeric_impute_strategy': 'mean', 'categorical_fill_value': None, 'numeric_fill_value': None}, 'One Hot Encoder':{'top_n': 10, 'features_to_encode': None, 'categories': None, 'drop': 'if_binary', 'handle_unknown': 'ignore', 'handle_missing': 'error'}, 'XGBoost Regressor':{'eta': 0.1, 'max_depth': 6, 'min_child_weight': 1, 'n_estimators': 100},}), GeneratedPipeline(parameters={'Imputer':{'categorical_impute_strategy': 'most_frequent', 'numeric_impute_strategy': 'mean', 'categorical_fill_value': None, 'numeric_fill_value': None}, 'One Hot Encoder':{'top_n': 10, 'features_to_encode': None, 'categories': None, 'drop': 'if_binary', 'handle_unknown': 'ignore', 'handle_missing': 'error'}, 'Extra Trees Regressor':{'n_estimators': 100, 'max_features': 'auto', 'max_depth': 6, 'min_samples_split': 2, 'min_weight_fraction_leaf': 0.0, 'n_jobs': -1},})], 'final_estimator': None, 'cv': None, 'n_jobs': -1},}),

इससे मुझे आश्चर्य होता है कि क्या हमें इस बारे में पुनर्विचार करने की आवश्यकता है कि हमें अपने स्टैक्ड एनसेंबलर को कौन सी इनपुट पाइपलाइन खिलानी चाहिए।

1. हम जिस धातुकर्मी का उपयोग कर रहे हैं (LinearRegressor) वह सबसे अच्छा नहीं है। मैंने इसे stacking_test शाखा के माध्यम से परीक्षण किया, जहां मैंने रिजसीवी (स्किकिट-लर्न डिफॉल्ट, लेकिन हमारे पास इवलएमएल में नहीं है) के लिए डिफ़ॉल्ट मेटलर्नर को अपडेट किया है, और एनसेंबलर बहुत बेहतर प्रदर्शन करता है:
   

@dshery के साथ चर्चा के बाद अगले चरण:

अन्य डेटासेट पर # 1 और # 3 (इलास्टिक नेट का उपयोग करके) आज़माएं, पूर्ण परीक्षण चलाएं, देखें कि क्या हम समग्र रूप से बेहतर प्रदर्शन प्राप्त कर सकते हैं।

@ Angela97lin छोटे डेटासेट के लिए बंटवारे के बारे में आपकी बातें सही हैं। आखिरकार, हमें छोटे डेटासेट को वास्तव में बड़े से अलग तरीके से संभालने की आवश्यकता होती है, उदाहरण के लिए पूरे डेटासेट पर केवल उच्च-गुना-गिनती xval का उपयोग करके, यहां तक ​​​​कि LOOCV, और यह सुनिश्चित करना कि हम कलाकारों की टुकड़ी के प्रशिक्षण के लिए अलग-अलग सिलवटों का निर्माण करते हैं।

मैं यह भी मानता हूं कि धातु अर्जित करने वाले को मजबूत नियमितीकरण का उपयोग करने की आवश्यकता है। मैंने H2O-3 StackedEnsemble में Elastic Net का उपयोग किया, और केवल एक बार याद किया कि लीडरबोर्ड में पहनावा दूसरे स्थान पर आया था। हर बार जब मैंने परीक्षण किया, तो यह पहला था। नियमितीकरण को कभी भी खराब मॉडलों को पहनावे के प्रदर्शन को कम करने की अनुमति नहीं देनी चाहिए।

और यह 50 मॉडल्स के पूरे लीडरबोर्ड को मेटल अर्नर में फीड कर रहा था। :-)

बस इस पर कुछ अतिरिक्त अपडेट पोस्ट कर रहे हैं:

सभी रिग्रेशन डेटासेट का उपयोग करके स्थानीय रूप से परीक्षण किया गया। परिणाम यहां या सिर्फ चार्ट यहां देखे जा सकते

इस से:

• सहमत @ रपेक! हमें निश्चित रूप से मजबूत नियमितीकरण का उपयोग करने के लिए धातुकर्मी को अपडेट करना चाहिए। ElasticNetCV कई डेटासेट पर हमारे LinearRegressor से बेहतर प्रदर्शन करता प्रतीत होता है। यह समस्या इसे ट्रैक करती है: https://github.com/alteryx/evalml/issues/1739
• @dsherry और मैंने अपनी डेटा विभाजन रणनीति पर फिर से चर्चा की: अभी, हम पहनावा के लिए डेटा को विभाजित करते हैं। हालाँकि, यह इस धारणा के तहत है कि हम चाहते हैं कि धातुकर्मी को इस पहनावा सूचकांक पर प्रशिक्षित किया जाए। स्किकिट-लर्न कार्यान्वयन के साथ, जब हम अपने StackedEnsembler को इस एसेम्बल इंडेक्स स्प्लिट पर प्रशिक्षित करते हैं, तो हम डेटा के इस छोटे से सेट पर इनपुट पाइपलाइन और मेटलर्नर दोनों को प्रशिक्षण देते हैं। शायद यही वजह है कि हम अच्छा प्रदर्शन नहीं कर रहे हैं। जबकि हमारे इनपुट पाइपलाइनों के लिए पैरामीटर अन्य डेटा द्वारा ट्यूनिंग से हैं, ये पाइपलाइन फिट नहीं हैं। लंबे समय में, अपने स्वयं के कार्यान्वयन को रोल करने से हम प्रशिक्षित पाइपलाइनों में एनसेंबलर को पास कर सकते हैं, इस स्थिति में हमारे पास वह व्यवहार होगा जो हम चाहते हैं। फिलहाल तो ऐसा नहीं है।

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

प्रयोग के परिणाम अच्छे दिखते हैं: https://alteryx.quip.com/4hEyAaTBZDap/Ensembling-Performance-Using-More-Data

अगला कदम:

• होल्डआउट सेट और सत्यापन स्कोर के साथ दोबारा जांच करें
• https://github.com/alteryx/evalml/issues/1930 . के लिए डिज़ाइन दस्तावेज़

कुछ खोज करने के बाद, हम मानते हैं कि मुद्दा यह नहीं है कि पहनावा कैसा प्रदर्शन करता है, बल्कि यह है कि हम पहनावा के प्रदर्शन की रिपोर्ट कैसे करते हैं। वर्तमान में, हम एक अलग पहनावा विभाजन करते हैं जो डेटा का 20% है, और फिर एक और ट्रेन-सत्यापन विभाजन करते हैं, और सत्यापन डेटा के रूप में पहनावा के स्कोर की रिपोर्ट करते हैं। इसका मतलब यह है कि कुछ मामलों में, पहनावा स्कोर की गणना बहुत कम संख्या में पंक्तियों का उपयोग करके की जाती है (जैसा कि ऊपर खुशी के डेटासेट के रूप में)।

पहनावा सूचकांकों के विभाजन को हटाकर और पहनावा के लिए cv प्रशिक्षण स्कोर की गणना करने की हमारी पुरानी पद्धति का उपयोग करके (इसे सभी डेटा दें, ट्रेन करें और एक गुना पर मान्य करें), हम देखते हैं कि पहनावा लगभग सभी मामलों में उच्च स्थान पर है, और ऊपर आता है कई और मामलों में # 1 के रूप में। इस बीच, सत्यापन स्कोर समान या थोड़ा बेहतर है।

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

ध्यान दें कि यह संयोजन सक्षम होने पर फिट समय में वृद्धि का कारण होगा: सभी पाइपलाइनों को अधिक डेटा (कोई आरक्षित पहनावा सूचकांक नहीं) दिखाई देता है, और पहनावा अधिक डेटा पर प्रशिक्षित होता है। मुझे लगता है कि यह ठीक है।

परिणाम यहां सारणीबद्ध हैं: https://alteryx.quip.com/jI2mArnWZfTU/Ensembling-vs-Best-Pipeline-Validation-Scores#MKWACADlCDt