Xgboost: Dask . के साथ वितरित कंप्यूटिंग

@mrocklin मुझे लगा कि डस्क का स्केलेर के साथ एकीकरण है। क्या आपने यह देखने के लिए हमारे स्केलेर रैपर पर एक नज़र डाली कि क्या यह उसके साथ काम करेगा?

एक वितरित प्रणाली के साथ अर्थपूर्ण रूप से एकीकरण आमतौर पर पुस्तकालय स्तर के बजाय प्रति-एल्गोरिदम स्तर पर किया जाना है। ऐसे कुछ तरीके हैं जिनसे SKLearn और Dask एक दूसरे की मदद कर सकते हैं, हां, लेकिन वे विशेष रूप से गहरे नहीं हैं।

डस्क डेटाफ्रेम एक अच्छी शुरुआत होगी। हमारे कोड बेस में, हमारे पास पांडा डेटाफ्रेम के लिए एक चेक है। यह वह जगह हो सकती है जहां शुरुआत के रूप में डैस्क डेटाफ्रेम फिट होगा।

तो क्या होगा यदि कोई मल्टी-टेराबाइट डस्क डेटाफ़्रेम के साथ आता है? क्या आप इसे सिर्फ पंडों में परिवर्तित करते हैं और आगे बढ़ते हैं? या क्या एक क्लस्टर में बुद्धिमानी से XGBoost को समानांतर करने का एक तरीका है, जो विभिन्न पांडा डेटाफ़्रेम की ओर इशारा करता है जो एक डस्क डेटाफ़्रेम बनाते हैं?

उपयोगकर्ता बैच आकार निर्दिष्ट कर सकते हैं? मुझे लगता है कि आंशिक_फिट के माध्यम से उपयोगकर्ताओं को लाभान्वित किया जा सकता है।

cc @tqchen जो कोड के वितरित भाग से अधिक परिचित है।

xgboost के वितरित संस्करण को एक वितरित जॉब लॉन्चर में जोड़ा जा सकता है, आदर्श रूप से xgboost में डेटा विभाजन फ़ीड प्राप्त करें और फिर जारी रखें।

@mrocklin मुझे लगता है कि सबसे प्रासंगिक हिस्सा xgboost-spark और xgboost-flink मॉड्यूल है, जो xgboost को स्पार्क/फ़्लिंक के मैपपार्टिशन फ़ंक्शन में एम्बेड करता है। मुझे लगता है कि Dask . में भी कुछ ऐसा ही होगा

xgboost की ओर से आवश्यकता यह है कि XGBoost रैबिट द्वारा इंटर प्रोसेस कनेक्शन को हैंडल करता है, और क्लाइंट साइड से एक ट्रैकर (जो प्रत्येक जॉब को जोड़ता है) शुरू करने की आवश्यकता होगी।

https://github.com/dmlc/xgboost/blob/master/jvm-packages/xgboost4j-spark/src/main/scala/ml/dmlc/xgboost4j/scala/spark/XGBoost.scala#L112 में प्रासंगिक कोड देखें

रैबिट को अन्य वितरित सिस्टम में एम्बेड करने के लिए डिज़ाइन किया गया है, इसलिए मुझे लगता है कि पाइथन पक्ष में समायोजन करना बहुत कठिन नहीं हो सकता है।

डस्क से अन्य वितरित सिस्टम लॉन्च करना आमतौर पर काफी उल्लेखनीय है। आप होस्टिंग वितरित सिस्टम (स्पार्क/फ़्लिंक/डस्क) से डेटा को xg-boost में कैसे स्थानांतरित करते हैं? या यह छोटे डेटा पर वितरित प्रशिक्षण के लिए है?

अधिक ठोस रूप से, मैं निम्नानुसार एक प्रणाली बनाने की उम्मीद करता हूं:

• प्रत्येक कार्य कार्यकर्ता पर मैं एक रैबिट सर्वर शुरू करता हूं। Dask इन रैबिट सर्वरों को एक दूसरे को खोजने के लिए पर्याप्त जानकारी देता है।
• मैं प्रत्येक कार्यकर्ता पर कुछ स्थानीय XGBoost राज्य बनाता हूं जो वर्तमान में प्रशिक्षण मॉडल का प्रतिनिधित्व करता है
• मैं बार-बार इस प्रति-कार्यकर्ता वस्तु पांडा डेटाफ्रेम या सुन्न सरणियों को खिलाता हूं
• मैं XGBoost से कुछ संकेत सुनता हूं जो मुझे रुकने के लिए कहता है

क्या यह आपकी अपेक्षा से मेल खाता है? क्या आपके लिए मुझे प्रासंगिक पायथन एपीआई पर इंगित करना आसान है?

हाँ, यहाँ प्रासंगिक जानकारी देखें https://github.com/dmlc/xgboost/blob/master/tests/distributed/ अजगर एपीआई के लिए।

इसके अतिरिक्त आपको ड्राइवर की तरफ से एक रैबिट ट्रैकर शुरू करने की आवश्यकता होगी (संभवत: वह स्थान जो डस्क ड्राइव करता है), यह यहां dmlc-submit स्क्रिप्ट में किया जाता है https://github.com/dmlc/dmlc-core /पेड़/मास्टर/ट्रैकर/dmlc_tracker

ठीक है, पहले से मेरी रूपरेखा भर रही हूँ:

किसी भी XGBoost कोड को चलाने से पहले हम एक रैबिट नेटवर्क सेट करते हैं

ड्राइवर/शेड्यूलर नोड पर हम एक रैबिट ट्रैकर शुरू करते हैं

envs = {'DMLC_NUM_WORKER' : nworker,
        'DMLC_NUM_SERVER' : nserver}

rabit = RabitTracker(hostIP=ip_address, nslave=num_workers)
envs.update(rabit.slave_envs())
rabit.start(args.num_workers)  # manages connections in background thread

मैं PSTracker शुरू करने के लिए भी इसी तरह की प्रक्रिया से गुजर सकता हूं। क्या यह उसी केंद्रीकृत मशीन पर होना चाहिए या नेटवर्क के भीतर कहीं और होना चाहिए? क्या इनमें से कुछ होना चाहिए? क्या यह उपयोगकर्ता विन्यास योग्य होना चाहिए?

आखिरकार मेरे पास मेरा ट्रैकर (और पस्ट्रैकर्स?) है जो रैबिट नेटवर्क और ब्लॉक में शामिल हो गया है।

rabit.join()  # join network

कार्यकर्ता नोड्स पर मुझे इन पर्यावरण चर (जो मैं सामान्य डस्क चैनलों के माध्यम से आगे बढ़ूंगा) को स्थानीय वातावरण में डंप करने की आवश्यकता है। तो बस xgboost.rabit.init() को कॉल करना पर्याप्त होना चाहिए

import os
os.environ.update(envs)
xgboost.rabit.init()

रैबिट कोड को देखकर ऐसा लगता है कि पर्यावरण चर ही इस जानकारी को प्रदान करने का एकमात्र तरीका है। क्या आप इसे सत्यापित कर सकते हैं? क्या ट्रैकर होस्ट/पोर्ट जानकारी को प्रत्यक्ष इनपुट के रूप में आपूर्ति करने का कोई तरीका है?

प्रशिक्षण

फिर मैं अपने numpy arrays/pandas dataframes/scipy sparse arrays को DMatrix ऑब्जेक्ट्स में कनवर्ट करता हूं, यह अपेक्षाकृत सरल लगता है। हालांकि मेरे पास प्रति कार्यकर्ता डेटा के कई बैच होने की संभावना है। क्या ट्रेन उपलब्ध होने पर अधिक डेटा के साथ कई बार कॉल करने का एक साफ तरीका है? मैं इन पंक्तियों पर टिप्पणियों के बारे में चिंतित हूं:

# Run training, all the features in training API is available.
# Currently, this script only support calling train once for fault recovery purpose.
bst = xgb.train(param, dtrain, num_round, watchlist, early_stopping_rounds=2)

क्या हमें प्रशिक्षण शुरू करने से पहले सभी डेटा के आने की प्रतीक्षा करने की आवश्यकता है?

उदाहरण डेटासेट / समस्या

यह मानते हुए कि मेरे पास सब कुछ सही है, तो क्या कोई मानक वितरित प्रशिक्षण उदाहरण है जिसे लोग प्रदर्शन के लिए उपयोग करते हैं?

पस्ट्राकर शुरू करने की कोई जरूरत नहीं है।

• ट्रैकर को केवल एक ही स्थान पर शुरू करने की आवश्यकता है, अनुसूचक (ड्राइवर) पर होने की संभावना है, इसमें कोई डेटा भारी काम नहीं है, और केवल कार्यों को जोड़ने का कार्य करता है।
• rabit.init . में env args को kwargs के रूप में पास किया जा सकता है
• चूंकि ट्री बूस्टिंग एक बैचेड एल्गोरिथम है, इसलिए हमें प्रशिक्षण शुरू करने से पहले सभी डेटा के अंतर्ग्रहण की प्रतीक्षा करने की आवश्यकता है।
  
  
  
  • ध्यान दें कि प्रत्येक कार्यकर्ता को केवल डेटा का एक शार्प (पंक्तियों का सबसेट) लेने की आवश्यकता होती है।
  
  
  • आदर्श रूप से, हमें डेटा को डीमैट्रिक्स में मिनी-बैच फैशन के रूप में पास करने के लिए डेटा इटर इंटरफ़ेस का उपयोग करना चाहिए, ताकि पूरे डेटासेट को मेमोरी में न बैठना पड़े
  
  
  • यह https://github.com/dmlc/xgboost/blob/master/include/xgboost/c_api.h#L117 के माध्यम से किया जाता है, जिसमें अभी तक एक अजगर आवरण नहीं है।
  
  
  • पहले समाधान के लिए, मैं सीधे सरणी से गुजरने की सलाह दूंगा
  
  

मेरे पास आज सुबह इसके साथ खेलने के लिए कुछ समय था। यहां परिणाम: https://github.com/mrocklin/dask-xgboost

अब तक यह केवल एकल इन-मेमोरी डेटासेट के वितरित शिक्षण को संभालता है। कुछ सवाल उठे:

1. डीमैट्रिक्स ऑब्जेक्ट्स को क्रमबद्ध करने और पास करने का सबसे अच्छा तरीका क्या है?
2. बूस्टर परिणाम को क्रमबद्ध करने और वापस करने का सबसे अच्छा तरीका क्या है?
3. मानचित्र के ऊपर सूचीबद्ध पर्यावरण चर rabit.init में तर्कों के लिए कैसे हैं? rabit.init में इनपुट का अपेक्षित रूप वास्तव में क्या है? slave_envs() का परिणाम rabit.init पर पास करना स्पष्ट रूप से काम नहीं करेगा क्योंकि यह एक सूची की अपेक्षा करता है। क्या हमें प्रत्येक कुंजीनाम को --key में बदलना चाहिए, शायद DMLC उपसर्ग को छोड़कर लोअरकेस में परिवर्तित करना चाहिए?
4. क्या शुद्धता का परीक्षण करने का कोई अच्छा तरीका है? हम दो बूस्टर ऑब्जेक्ट्स की तुलना कैसे करते हैं? क्या हमें वितरित प्रशिक्षण से ठीक उसी परिणाम और अनुक्रमिक प्रशिक्षण की अपेक्षा करनी चाहिए?

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

rabit.init(['DMLC_KEY1=VALUE1', 'DMLC_KEY2=VALUE2']

• आम तौर पर वितरित और एकल मशीन से प्रशिक्षित बूस्टर समान नहीं होते हैं, लेकिन यहां कुछ चीजों की जांच की जा सकती है
  
  
  
  • सभी कार्यकर्ता से लौटा बूस्टर समान होना चाहिए
  
  
  • भविष्य कहनेवाला सत्यापन त्रुटि की तलाश में, यह लगभग सिंगल मशीन केस जितना कम होना चाहिए
  
  

इसका उपयोग कैसे किया जाता है, इसके बारे में आम तौर पर दो और प्रश्न (मुझे XGBoost के साथ कोई अनुभव नहीं है और मशीन सीखने के साथ केवल थोड़ा सा अनुभव है, कृपया मेरी अज्ञानता को क्षमा करें)।

1. क्या एक ही इनपुट डेटा पर एकाधिक श्रमिकों का उपयोग करना उचित है? (XGBoost कम्प्यूटेशनल रूप से बाध्य है?)
2. यदि हम बड़े डेटासेट पर काम करते हैं तो क्या मुझे प्रत्येक XGBoost कार्यकर्ता को यह बताने के लिए कुछ विशेष करना होगा कि उसका डेटा उसके साथियों से अलग है?

कौन सा उपयोग मामला अधिक सामान्य है?

प्रत्येक कार्य को डेटा के एक अलग विभाजन (पंक्तियों द्वारा) पर काम करना चाहिए, उन्हें एक ही इनपुट डेटा को नहीं देखना चाहिए।

• यदि डेटा पर्याप्त बड़ा नहीं है, तो एक बहु-थ्रेडेड वर्जन को करना चाहिए
• प्रत्येक कार्य अपने विभाजन पर अलग से आंकड़े एकत्र करेगा और एक दूसरे के साथ समन्वयित करेगा

यह आम तौर पर स्पार्क/फ्लिंक जैसे ढांचे में मैपपार्टिशन ऑपरेशन से मेल खाता है

मान लें कि मेरे डेटा सेट में 8 पंक्तियाँ, 4 कॉलम हैं, अगर हम दो कार्यकर्ता शुरू करते हैं

• कार्यकर्ता 0 पंक्ति 0-3 . से पढ़ता है
• कार्यकर्ता 1 पंक्ति 4 -7 . से पढ़ता है

ठीक है, अब जो हो रहा है वह थोड़ा साफ है। यह अच्छा होगा यदि हमारे पास परिणामों का उपभोग करने की कुछ क्षमता हो क्योंकि वे प्रत्येक कार्यकर्ता पर उत्पन्न हुए थे, लेकिन हमने अभी इसके लिए काम किया है। यहाँ वर्तमान समाधान है:

1. क्लस्टर पर डस्क ऐरे या डेटाफ़्रेम को बनाए रखें, इसके समाप्त होने की प्रतीक्षा करें
2. पता लगाएं कि प्रत्येक खंड/विभाजन कहां समाप्त हुआ
3. प्रत्येक कार्यकर्ता से कहें कि वह उन हिस्सों/विभाजनों को ठीक-ठीक जोड़ दें और उन पर प्रशिक्षण दें

यह समाधान प्रबंधनीय प्रतीत होता है, लेकिन आदर्श नहीं है। यह सुविधाजनक होगा यदि xgboost-python परिणाम आने पर स्वीकार कर सकता है। हालाँकि मुझे लगता है कि अगली बात यह है कि इसे व्यवहार में आजमाना है।

मैं उदाहरण के लिए इंटरनेट पर चारों ओर देखने जा रहा हूं। अगर किसी को कृत्रिम समस्या होती है तो मैं आसानी से numpy या पांडा एपीआई के साथ उत्पन्न कर सकता हूं जिसका स्वागत किया जाएगा। तब तक, मेरे लैपटॉप पर यादृच्छिक डेटा के साथ एक छोटा सा उदाहरण यहां दिया गया है:

In [1]: import dask.dataframe as dd

In [2]: df = dd.demo.make_timeseries('2000', '2001', {'x': float, 'y': float, 'z': int}, freq='1s', partition_freq=
   ...: '1D')  # some random time series data

In [3]: df.head()
Out[3]: 
                            x         y     z
2000-01-01 00:00:00  0.778864  0.824796   977
2000-01-01 00:00:01 -0.019888 -0.173454  1023
2000-01-01 00:00:02  0.552826  0.051995  1083
2000-01-01 00:00:03 -0.761811  0.780124   959
2000-01-01 00:00:04 -0.643525  0.679375   980

In [4]: labels = df.z > 1000

In [5]: del df['z']

In [6]: df.head()
Out[6]: 
                            x         y
2000-01-01 00:00:00  0.778864  0.824796
2000-01-01 00:00:01 -0.019888 -0.173454
2000-01-01 00:00:02  0.552826  0.051995
2000-01-01 00:00:03 -0.761811  0.780124
2000-01-01 00:00:04 -0.643525  0.679375

In [7]: labels.head()
Out[7]: 
2000-01-01 00:00:00    False
2000-01-01 00:00:01     True
2000-01-01 00:00:02     True
2000-01-01 00:00:03    False
2000-01-01 00:00:04    False
Name: z, dtype: bool

In [8]: from dask.distributed import Client

In [9]: c = Client()  # creates a local "cluster" on my laptop

In [10]: from dask_xgboost import train
/home/mrocklin/Software/anaconda/lib/python3.5/site-packages/sklearn/cross_validation.py:44: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.
  "This module will be removed in 0.20.", DeprecationWarning)

In [11]: param = {'max_depth': 2, 'eta': 1, 'silent': 1, 'objective': 'binary:logistic'}  # taken from example

In [12]: bst = train(c, param, df, labels)
/home/mrocklin/Software/anaconda/lib/python3.5/site-packages/sklearn/cross_validation.py:44: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.
  "This module will be removed in 0.20.", DeprecationWarning)
/home/mrocklin/Software/anaconda/lib/python3.5/site-packages/sklearn/cross_validation.py:44: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.
  "This module will be removed in 0.20.", DeprecationWarning)
/home/mrocklin/Software/anaconda/lib/python3.5/site-packages/sklearn/cross_validation.py:44: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.
  "This module will be removed in 0.20.", DeprecationWarning)
/home/mrocklin/Software/anaconda/lib/python3.5/site-packages/sklearn/cross_validation.py:44: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.
  "This module will be removed in 0.20.", DeprecationWarning)
[14:46:20] Tree method is automatically selected to be 'approx' for faster speed. to use old behavior(exact greedy algorithm on single machine), set tree_method to 'exact'
[14:46:20] Tree method is automatically selected to be 'approx' for faster speed. to use old behavior(exact greedy algorithm on single machine), set tree_method to 'exact'
[14:46:20] Tree method is automatically selected to be 'approx' for faster speed. to use old behavior(exact greedy algorithm on single machine), set tree_method to 'exact'
[14:46:20] Tree method is automatically selected to be 'approx' for faster speed. to use old behavior(exact greedy algorithm on single machine), set tree_method to 'exact'

In [13]: bst
Out[13]: <xgboost.core.Booster at 0x7fbaacfd17b8>

यदि कोई देखना चाहता है तो प्रासंगिक कोड यहां है: https://github.com/mrocklin/dask-xgboost/blob/master/dask_xgboost/core.py

जैसा कि मैंने कहा, मैं XGBoost में नया हूं, इसलिए शायद मुझे चीजें याद आ रही हैं।

कोशिश करने के लिए एक विशिष्ट खिलौना उदाहरण https://github.com/dmlc/xgboost/tree/master/demo/data में है
हालांकि यह libsvm प्रारूप में है, और इसे numpy में लाने के लिए थोड़ा पार्सिंग की आवश्यकता है

कुछ भी बड़ा (जिसके लिए आपको वास्तव में क्लस्टर की आवश्यकता होगी)? या मनमाना आकार का डेटासेट उत्पन्न करने का कोई मानक तरीका है?

या, शायद एक बेहतर सवाल यह है: "आप (या इस मुद्दे को पढ़ने वाला कोई और) यहां क्या देखना पसंद करेंगे?"

भवन अब भविष्यवाणी करते हैं। अगर मैं मॉडल को वापस एक कार्यकर्ता (अचार/अनपिकल प्रक्रिया के माध्यम से जा रहा हूं) में ले जाता हूं और फिर कुछ डेटा पर bst.predict पर कॉल करता हूं तो मुझे निम्न त्रुटि मिलती है:

Doing rabit call after Finalize

मेरी धारणा यह थी कि, इस बिंदु पर, मॉडल स्व-निहित है और अब रैबिट का उपयोग करने की आवश्यकता नहीं है। ऐसा लगता है कि क्लाइंट मशीन पर ठीक काम करता है। predict पर कॉल करते समय कोई विचार मुझे यह त्रुटि क्यों प्राप्त हो सकती है?

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

मुझे लगता है कि जब तक यह सामान्य डेटासेट के लिए ठीक काम करता है, यह एक दिलचस्प प्रारंभिक बिंदु है।

वैसे भी मध्यम डेटा के लिए क्लस्टर का उपयोग करने के कारण हैं (क्लस्टर एनवी में शेड्यूलिंग में आसानी), कुछ pyspark उपयोगकर्ता इसे आज़माने के लिए इच्छुक हो सकते हैं यदि हम इसे थोड़ा विज्ञापित करते हैं

डेटासेट पर परीक्षण करना जो वास्तव में मायने रखता है, कठिन था, उदाहरण के लिए (1 बिलियन पंक्तियों के साथ 1 डेटासेट आज़माएं)। कागल कुछ बड़े डेटासेट हो सकते हैं जो प्रासंगिक हो सकते हैं जो लगभग 10 मिलियन हैं।

यह रिपॉजिटरी एयरलाइंस डेटासेट के खिलाफ प्रयोग दिखाती है, जो मुझे लगता है कि दसियों लाख पंक्तियों और दसियों कॉलम में है (हजारों एक-हॉट-एन्कोडिंग के बाद?) उनके बेंचमार्क के लिए ऐसा लगता है कि उन्होंने 100k पंक्तियों का नमूना लिया और कृत्रिम रूप से उत्पन्न किया इस नमूने से बड़े डेटासेट। संभवत: यदि आवश्यक हो तो हम इसे बढ़ा सकते हैं।

यहाँ इस डेटा का उपयोग एक ही कोर पर पांडा और xgboost के साथ करने का एक उदाहरण है। डेटा प्रीपे, पैरामीटर, या इसे ठीक से कैसे करें, इस पर किसी भी अनुशंसा का स्वागत किया जाएगा।

In [1]: import pandas as pd

In [2]: df = pd.read_csv('train-0.1m.csv')

In [3]: df.head()
Out[3]: 
  Month DayofMonth DayOfWeek  DepTime UniqueCarrier Origin Dest  Distance  \
0   c-8       c-21       c-7     1934            AA    ATL  DFW       732   
1   c-4       c-20       c-3     1548            US    PIT  MCO       834   
2   c-9        c-2       c-5     1422            XE    RDU  CLE       416   
3  c-11       c-25       c-6     1015            OO    DEN  MEM       872   
4  c-10        c-7       c-6     1828            WN    MDW  OMA       423   

  dep_delayed_15min  
0                 N  
1                 N  
2                 N  
3                 N  
4                 Y  

In [4]: labels = df.dep_delayed_15min == 'Y'

In [5]: del df['dep_delayed_15min']

In [6]: df = pd.get_dummies(df)

In [7]: len(df.columns)
Out[7]: 652

In [8]: import xgboost as xgb
/home/mrocklin/Software/anaconda/lib/python3.5/site-packages/sklearn/cross_validation.py:44: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.
  "This module will be removed in 0.20.", DeprecationWarning)

In [9]: dtrain = xgb.DMatrix(df, label=labels)

In [10]: param = {}  # Are there better choices for parameters?  I could use help here

In [11]: bst = xgb.train(param, dtrain)  # or other parameters here?
[17:50:28] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 124 extra nodes, 0 pruned nodes, max_depth=6
[17:50:30] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 120 extra nodes, 0 pruned nodes, max_depth=6
[17:50:32] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 120 extra nodes, 0 pruned nodes, max_depth=6
[17:50:33] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 116 extra nodes, 0 pruned nodes, max_depth=6
[17:50:35] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 112 extra nodes, 0 pruned nodes, max_depth=6
[17:50:36] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 114 extra nodes, 0 pruned nodes, max_depth=6
[17:50:38] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 106 extra nodes, 0 pruned nodes, max_depth=6
[17:50:39] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 116 extra nodes, 0 pruned nodes, max_depth=6
[17:50:41] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 104 extra nodes, 0 pruned nodes, max_depth=6
[17:50:43] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 100 extra nodes, 0 pruned nodes, max_depth=6

In [12]: test = pd.read_csv('test.csv')

In [13]: test.head()
Out[13]: 
  Month DayofMonth DayOfWeek  DepTime UniqueCarrier Origin Dest  Distance  \
0   c-7       c-25       c-3      615            YV    MRY  PHX       598   
1   c-4       c-17       c-2      739            WN    LAS  HOU      1235   
2  c-12        c-2       c-7      651            MQ    GSP  ORD       577   
3   c-3       c-25       c-7     1614            WN    BWI  MHT       377   
4   c-6        c-6       c-3     1505            UA    ORD  STL       258   

  dep_delayed_15min  
0                 N  
1                 N  
2                 N  
3                 N  
4                 Y  

In [14]: test_labels = test.dep_delayed_15min == 'Y'

In [16]: del test['dep_delayed_15min']

In [17]: test = pd.get_dummies(test)

In [18]: len(test.columns)  # oops, looks like the columns don't match up
Out[18]: 670

In [19]: dtest = xgb.DMatrix(test)

In [20]: predictions = bst.predict(dtest)  # this fails because of mismatched columns

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

cc @TomAugspurger , जो उस तरह के आदमी की तरह लगता है, जो इस पर विचार कर सकता है।

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

भविष्यवाणी के साथ कुछ मुद्दों में चल रहा है। दो सवाल:

1. क्या मैं एक ही रैबिट सत्र में कई बार Booster.predict पर कॉल कर सकता हूँ?
2. क्या मैं अलग थ्रेड पर rabit.init , Booster.predict और rabit.finalize पर कॉल कर सकता हूं?

वर्तमान में मैं एक नया ट्रैकर बनाता हूं, और कार्यकर्ता के मुख्य धागे पर rabit.init पर कॉल करता हूं। यह ठीक काम करता है। हालांकि जब मैं कार्यकर्ता धागे में Booster.predict कॉल करता हूं (प्रत्येक कार्य कार्यकर्ता गणना के लिए थ्रेड पूल रखता है) मुझे Doing rabit call after Finalize जैसी त्रुटियां मिलती हैं। कोई सुझाव?

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

मैं इसके बारे में उत्सुक हूँ। एक कार्यकर्ता से मेरे क्लाइंट मशीन में प्रशिक्षित मॉडल को क्रमबद्ध-स्थानांतरण-deserialize करने के बाद यह सामान्य डेटा पर ठीक काम करता प्रतीत होता है, भले ही कोई रैबिट नेटवर्क न हो। ऐसा लगता है कि रैबिट से प्रशिक्षित मॉडल का इस्तेमाल बिना रैबिट के डेटा की भविष्यवाणी करने के लिए किया जा सकता है। ऐसा भी लगता है कि यह उत्पादन में आवश्यक होगा। क्या आप यहां रैबिट-प्रशिक्षित मॉडल का उपयोग करने की बाधाओं के बारे में अधिक बता सकते हैं?

उदाहरण डेटासेट / समस्या
यह मानते हुए कि मेरे पास सब कुछ सही है, तो क्या कोई मानक वितरित प्रशिक्षण उदाहरण है जिसे लोग प्रदर्शन के लिए उपयोग करते हैं?

मुझे इस प्रयोग के परिणामों को पुन: प्रस्तुत करना अच्छा लगेगा:

https://github.com/Microsoft/LightGBM/wiki/Experiments#parallel -experiment

XGBoost (#1950) के नए बिनिंग + फास्ट हिस्ट विकल्प के साथ, समान परिणाम प्राप्त करना संभव होना चाहिए।

कोशिश करने के लिए एक विशिष्ट खिलौना उदाहरण https://github.com/dmlc/xgboost/tree/master/demo/data में है
हालांकि यह libsvm प्रारूप में है, और इसे numpy में लाने के लिए थोड़ा पार्सिंग की आवश्यकता है

आपको इस पीआर में स्केलेर में रुचि हो सकती है: https://github.com/scikit-learn/scikit-learn/pull/935

@mrocklin मॉडल का पुन: उपयोग करने पर कोई बाधा नहीं है। तो वितरित संस्करण में प्रशिक्षित मॉडल का उपयोग धारावाहिक संस्करण में किया जा सकता है। यह सिर्फ इतना है कि भविष्यवक्ता की वर्तमान सीमा (जब खरगोश के साथ संकलित होती है) में प्रशिक्षण समारोह के साथ मिश्रित कार्य होता है (इसलिए रैबिट कॉल हुआ)।

अब जब आप इसे कहते हैं, तो मुझे लगता है कि हमारे पास समस्या का समाधान हो सकता है। समस्या को हल करने से पहले केवल rabit.init (बिना कुछ पास किए, और भविष्यवक्ता को लगता है कि यह एकमात्र कार्यकर्ता है) करें

हां। वास्तव में यह समस्या का समाधान करता है। dask-xgboost अब भविष्यवाणी का समर्थन करता है: https://github.com/mrocklin/dask-xgboost/commit/827a03d96977cda8d104899c9f42f52dac446165

वर्कअराउंड @tqchen के लिए धन्यवाद!

मेरे स्थानीय लैपटॉप पर एयरलाइंस डेटासेट के एक छोटे से नमूने पर dask.dataframe और xgboost के साथ एक वर्कफ़्लो है। क्या यह सबको ठीक लगता है? क्या एक्सजीबीओस्ट के एपीआई तत्व हैं जो मुझे यहां याद आ रहे हैं?

In [1]: import dask.dataframe as dd

In [2]: import dask_xgboost as dxgb

In [3]: df = dd.read_csv('train-0.1m.csv')

In [4]: df.head()
Out[4]: 
  Month DayofMonth DayOfWeek  DepTime UniqueCarrier Origin Dest  Distance  \
0   c-8       c-21       c-7     1934            AA    ATL  DFW       732   
1   c-4       c-20       c-3     1548            US    PIT  MCO       834   
2   c-9        c-2       c-5     1422            XE    RDU  CLE       416   
3  c-11       c-25       c-6     1015            OO    DEN  MEM       872   
4  c-10        c-7       c-6     1828            WN    MDW  OMA       423   

  dep_delayed_15min  
0                 N  
1                 N  
2                 N  
3                 N  
4                 Y  

In [5]: labels = df.dep_delayed_15min == 'Y'

In [6]: del df['dep_delayed_15min']

In [7]: df = df.categorize()

In [8]: df = dd.get_dummies(df)

In [9]: data_train, data_test = df.random_split([0.9, 0.1], random_state=123)

In [10]: labels_train, labels_test = labels.random_split([0.9, 0.1], random_state=123)

In [11]: from dask.distributed import Client

In [12]: client = Client()  # in a large-data situation I probably should have done this before calling categorize above (which requires computation)

In [13]: param = {}  # Are there better choices for parameters?

In [14]: bst = dxgb.train(client, {}, data_train, labels_train)
[14:00:46] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 120 extra nodes, 0 pruned nodes, max_depth=6
[14:00:48] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 120 extra nodes, 0 pruned nodes, max_depth=6
[14:00:50] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 122 extra nodes, 0 pruned nodes, max_depth=6
[14:00:53] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 118 extra nodes, 0 pruned nodes, max_depth=6
[14:00:55] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 120 extra nodes, 0 pruned nodes, max_depth=6
[14:00:57] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 114 extra nodes, 0 pruned nodes, max_depth=6
[14:00:59] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 118 extra nodes, 0 pruned nodes, max_depth=6
[14:01:01] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 118 extra nodes, 0 pruned nodes, max_depth=6
[14:01:04] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 94 extra nodes, 0 pruned nodes, max_depth=6
[14:01:06] src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 102 extra nodes, 0 pruned nodes, max_depth=6

In [15]: bst
Out[15]: <xgboost.core.Booster at 0x7f689803af60>

In [16]: predictions = dxgb.predict(client, bst, data_test)

In [17]: predictions
Out[17]: 
Dask Series Structure:
npartitions=1
None    float32
None        ...
Name: predictions, dtype: float32
Dask Name: _predict_part, 9 tasks

मेरा अल्पकालिक उद्देश्य इस बारे में एक संक्षिप्त ब्लॉगपोस्ट लिखना है ताकि उम्मीद है कि कोई और व्यक्ति जिसे XGBoost के साथ अधिक अनुभव हो और अधिक समय के साथ इस परियोजना को अपनाने और इसे आगे बढ़ाने के लिए साथ आए। (मैं, यहां हर किसी की तरह, उसी समय इस तरह की कुछ अन्य परियोजनाओं पर काम कर रहा हूं।)

मैं एयरलाइंस डेटासेट के लिए आंशिक हूं क्योंकि मेरे पास पहले से ही इसे S3 बाल्टी में है। हालांकि मैं सहमत हूं कि क्रिटो डेटासेट बड़े पैमाने पर बेहतर प्रदर्शन के लिए तैयार होगा।

मुझे अभी भी यकीन नहीं है कि किस पैरामीटर का उपयोग करना है या परिणाम का न्याय कैसे करना है। मापदंडों के लिए मैं यहां @szilard से प्रयोग का उपयोग कर सकता हूं। क्या भविष्यवाणियों का न्याय करने का कोई अच्छा तरीका है? उदाहरण के लिए क्या हम predictions > 0.5 से मिलान करने के लिए labels_test की तलाश कर रहे हैं?

शायद द्विआधारी वर्गीकरण (विशेष रूप से अनुसंधान या प्रतियोगिता सेटिंग्स में) के लिए भविष्य कहनेवाला प्रदर्शन का मूल्यांकन करने का सबसे आम तरीका आरओसी वक्र (एयूसी) के तहत क्षेत्र का उपयोग करना है, हालांकि वास्तविक दुनिया के अनुप्रयोगों में किसी को "व्यवसाय" मूल्यों के साथ संरेखित मीट्रिक का उपयोग करना चाहिए। मॉडलों का उपयोग करके उत्पादित।

उदाहरण के लिए क्या हम लेबल_टेस्ट से मेल खाने के लिए पूर्वानुमान> 0.5 की तलाश कर रहे हैं?

हां। यदि आप परीक्षण सेट पर इसका माध्य लेते हैं, तो यह परीक्षण सटीकता है। लेकिन यह संभव है कि डेटासेट असंतुलित हो (क्लिक की तुलना में क्लिक का बहुत अधिक अभाव)। उस स्थिति में ROC AUC स्कोर एक बेहतर मीट्रिक है।

from sklearn.metrics import roc_auc_score
print(roc_auc_score(labels_test, predictions))

यह मानते हुए कि predictions परीक्षण सेट में प्रत्येक पंक्ति के लिए मॉडल द्वारा अनुमानित सकारात्मक संभावनाओं का एक 1D सरणी है।

@mrocklin एक अनुवर्ती प्रश्न, क्या dask बहु-थ्रेडेड कार्यकर्ता नौकरियों की अनुमति देता है? मुझे पता है कि यह जीआईएल के कारण अजगर के लिए बहुत प्रासंगिक नहीं है। लेकिन xgboost एक दूसरे के साथ वितरित रूप से समन्वय करते हुए प्रति कार्यकर्ता बहु-थ्रेडेड प्रशिक्षण की अनुमति दे सकता है। हमें हमेशा xgboost के nthread तर्कों को उस कार्यकर्ता के काम करने वाले कोर की संख्या के रूप में सेट करना चाहिए

संक्षिप्त उत्तर "हां" है। डस्क का अधिकांश उपयोग न्यूमपी, पांडा, एसकेलर्न और अन्य परियोजनाओं के साथ है जो ज्यादातर सिर्फ सी और फोरट्रान कोड हैं, जो पायथन के साथ लिपटे हुए हैं। GIL इन पुस्तकालयों को प्रभावित नहीं करता है। कुछ लोग पाइस्पार्क आरडीडी के समान अनुप्रयोगों के लिए डैस्क का उपयोग करते हैं (देखें dask.bag ) और इससे प्रभावित होंगे। हालांकि यह समूह अल्पमत में है।

तो हाँ, Dask बहु-थ्रेडेड कार्यों की अनुमति देता है। हम XGBoost को एकाधिक थ्रेड्स का उपयोग करने के लिए कैसे कह सकते हैं? मेरे अब तक के प्रयोगों में मैं बिना किसी पैरामीटर को बदले उच्च CPU उपयोग देखता हूं, तो हो सकता है कि डिफ़ॉल्ट रूप से सब कुछ ठीक से काम करे?

XGBoost डिफ़ॉल्ट रूप से बहु-थ्रेडेड का उपयोग करता है, और यदि nthread सेट नहीं है, तो मशीन पर (उस कार्यकर्ता के बजाय) सभी उपलब्ध सीपीयू थ्रेड्स का उपयोग करेगा। यह दौड़ की स्थिति पैदा कर सकता है जब एक ही मशीन को कई कर्मचारी सौंपे जाते हैं।

इसलिए nthread पैरामीटर को वर्कर द्वारा उपयोग किए जाने वाले अधिकतम कोर पर सेट करना हमेशा अच्छा होता है। आमतौर पर एक अच्छा अभ्यास लगभग 4 थ्रेड प्रति कार्यकर्ता का उपयोग किया जाता है

ज़रूर, में पूरा किया जाना चाहिए
https://github.com/mrocklin/dask-xgboost/commit/c22d066b67c78710d5ad99b8620edc55182adc8f

सोम, 20 फरवरी, 2017 को शाम 6:31 बजे, तियानकी चेन सूचनाएं @github.com
लिखा था:

XGBoost डिफ़ॉल्ट रूप से मल्टी-थ्रेडेड का उपयोग करता है, और सभी उपलब्ध सीपीयू का उपयोग करेगा
मशीन पर धागे (उस कार्यकर्ता के बजाय) यदि nthread सेट नहीं है।
यह दौड़ की स्थिति पैदा कर सकता है जब एक से अधिक श्रमिकों को एक ही सौंपा जाता है
मशीन।

इसलिए nthread पैरामीटर को अधिकतम संख्या में सेट करना हमेशा अच्छा होता है
कोर कार्यकर्ता को उपयोग करने की अनुमति है। आमतौर पर एक अच्छा अभ्यास कहने के आसपास उपयोग किया जाता है
प्रति कार्यकर्ता 4 धागा

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/dmlc/xgboost/issues/2032#issuecomment-281205747 , या म्यूट करें
सूत्र
https://github.com/notifications/unsubscribe-auth/AASszPELRoeIvqEzyJhkKumIs-vd0PHiks5reiJngaJpZM4L_PXa
.

नोटबुक: https://gist.github.com/19c89d78e34437e061876a9872f4d2df
लघु स्क्रीनकास्ट (छह मिनट): https://youtu.be/Cc4E-PdDSro

आलोचनात्मक प्रतिक्रिया का बहुत स्वागत है। फिर से, कृपया इस क्षेत्र में मेरी अज्ञानता को क्षमा करें।

@mrocklin महान डेमो! मुझे लगता है कि परम निर्देश में 'tree_method': 'hist', 'grow_policy': 'lossguide' का उपयोग करके रनटाइम प्रदर्शन (और संभवतः स्मृति उपयोग) में काफी सुधार किया जा सकता है।

धन्यवाद @ogrisel। उन मापदंडों के साथ प्रशिक्षण का समय छह मिनट से एक मिनट तक चला जाता है। स्मृति उपयोग हालांकि वही रहता है।

ठीक है, इस पर वापस आ रहा हूँ। क्या ट्रेन के अलावा कोई XGBoost संचालन है और हम भविष्यवाणी करते हैं कि हमें इसे लागू करना चाहिए?

@tqchen या @ogrisel यदि आप में से किसी के पास https://github.com/mrocklin/dask-xgboost/blob/master/dask_xgboost/core.py पर कार्यान्वयन को देखने का समय है तो मैं आभारी रहूंगा। हालांकि मैं समझता हूं कि प्राथमिकता सूची में विदेशी कोडबेस को देखना हमेशा उच्च नहीं होता है।

अगर सब कुछ ठीक है तो मैं रीडमे में कुछ और जोड़ूंगा, पीपीपीआई को प्रकाशित करूंगा, और फिर हम शायद इस मुद्दे को बंद कर सकते हैं।

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

मैंने dask-xgboost को PyPI पर धकेल दिया है और इसे https://github.com/dask/dask-xgboost पर स्थानांतरित कर दिया है

यहां आपकी मदद के लिए @tqchen और @ogrisel को धन्यवाद। सहयोग ने इसे अपेक्षाकृत आसान बना दिया।

अगर लोग बेंचमार्क चलाना चाहते हैं तो मुझे उनकी मदद करने में खुशी होगी। तब तक बंद।