Xgboost: [नई विशेषता] वृक्ष निर्माण में मोनोटोनिक बाधाएं

एक प्रयोगात्मक संस्करण https://github.com/dmlc/xgboost/pull/1516 में उपलब्ध कराया गया है https://github.com/tqchen/xgboost ,

निम्नलिखित विकल्पों को चालू करें (संभवतः अजगर, आर एपीआई के माध्यम से संभव है)

monotone_constraints = "(0,1,1,0)"

दो तर्क हैं

• monotone_constraints सुविधाओं की संख्या की लंबाई में एक सूची है, 1 मोनोटोनिक वृद्धि को इंगित करता है, - 1 का अर्थ है कम होना, 0 का अर्थ कोई बाधा नहीं है। यदि यह सुविधाओं की संख्या से कम है, तो 0 को गद्देदार किया जाएगा।
  
  
  
  • वर्तमान में यह अजगर के टपल प्रारूप का समर्थन करता है, आप r . का उपयोग करते समय चीजों को स्ट्रिंग के रूप में पास कर सकते हैं
  
  

सत्यापित करने के लिए चीजें

• [x] मूल ट्री बूस्टर की गति धीमी नहीं होती है (मैंने कोड संरचना को थोड़ा बदल दिया है, सिद्धांत रूप में टेम्प्लेट ऑप्टिमाइज़ेशन उन्हें इनलाइन कर देगा, लेकिन पुष्टि करने की आवश्यकता है)
• [x] मोनोटोनिक रिग्रेशन की गति और शुद्धता
• [x] इस बाधा को पेश करके प्रदर्शन

ज्ञात सीमाएं

वर्तमान में केवल बहु-कोर पर सटीक लालची एल्गोरिथ्म का समर्थन किया है। वितरित संस्करण में अभी तक उपलब्ध नहीं है

@tqchen मुझे कुछ अन्य मॉडलों के प्रदर्शन बनाम परीक्षण के लिए मोनोटोन बाधाओं के साथ कुछ जीबीएम बनाने के लिए आज काम पर एक अनुरोध मिला। यह एक ट्वीडी विचलन हानि के साथ होगा, इसलिए मुझे एक कस्टम हानि फ़ंक्शन के साथ जाना होगा जैसा कि आज है।

किसी भी मामले में, एक ही समय में मदद करने और कुछ काम करने का एक अच्छा मौका लगता है।

यहाँ बात के आधार पर, GBM(R Package) केवल स्थानीय रूप से एकरसता को लागू करता है।
क्या आप स्पष्ट कर सकते हैं कि XGBoost मोनोटोनिक बाधाओं को कैसे लागू करता है?
यह बहुत अच्छा होगा यदि XGBoost वैश्विक बाधाओं को लागू कर सके।

मुझे समझ में नहीं आता कि स्थानीय या वैश्विक बाधा से आपका क्या मतलब है, क्या आप विस्तार से बता सकते हैं?

क्षमा करें, मैं गलत लिंक पेस्ट करता हूं, यहां सही है (लिंक)
प्रत्येक पेड़ केवल रुचि वाले फीचर के कुछ सबसेट में मोनोटोनिक बाधा का पालन कर सकता है, ताकि कई पेड़ एक साथ मिलकर उस फीचर की पूरी श्रृंखला पर समग्र एकरसता का उल्लंघन कर सकें।

ठीक है, मेरी समझ में, इसे विश्व स्तर पर लागू किया गया है। इसे आजमाने के लिए आपका स्वागत है।

एक अविभाज्य प्रतिगमन के संदर्भ में एकरसता बाधा के कुछ सरल परीक्षण किए। आप यहां कोड और कुछ बहुत ही संक्षिप्त दस्तावेज पा सकते हैं:

https://github.com/XiaoxiaoWang87/xgboost_mono_test/blob/master/xgb_monotonicity_constraint_testing1-univariate.ipynb

कुछ प्रारंभिक अवलोकन:

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

पता चला कि मैं बाधा = -1 मामले में एक बग पेश करता हूं। मैंने एक फिक्स को धक्का दिया, कृपया देखें कि नवीनतम संस्करण अच्छी तरह से काम करता है या नहीं। कृपया यह भी जांचें कि क्या यह तब काम करता है जब कई बाधाएं हों

@tqchen मैंने

आइए पुष्टि करें कि कुछ मानक डेटासेट पर मूल संस्करण बनाम गति घट रही है, तो हम इसे मर्ज कर सकते हैं

@tqchen मैंने दो चर मॉडल का परीक्षण किया, एक बढ़ती हुई बाधा के साथ और एक घटते हुए:

params_constrained = params.copy()
params_constrained['updater'] = "grow_monotone_colmaker,prune"
params_constrained['monotone_constraints'] = "(1,-1)"

परिणाम अच्छे हैं

मैं आज दोपहर कुछ समय परीक्षण करने के लिए थोड़ा समय निकालने की कोशिश करूंगा।

मैंने मोनटोन विकल्पों की स्वचालित पहचान की अनुमति देने के लिए #1516 में एक अपडेट किया, अब उपयोगकर्ता को केवल monotone_constraints = "(0,1,1,0)" में पास करने की आवश्यकता है, कृपया जांचें कि यह काम करता है या नहीं।

यदि गति परीक्षण ठीक चल रहा है, तो मैं इसे मर्ज कर दूंगा, और हम ट्यूटोरियल जोड़ने के अगले चरण पर आगे बढ़ते हैं

@madrury @XiaoxiaoWang87

यहाँ बहुभिन्नरूपी मामले के लिए जोड़े गए परीक्षण:

https://github.com/XiaoxiaoWang87/xgboost_mono_test/blob/master/xgb_monotonicity_constraint_testing2-multivariate.ipynb

• मैं अब पुष्टि करता हूं कि दोनों मोनोटोनिक बाधा = 1 और = -1 उम्मीद के मुताबिक काम करते हैं।
• एकरसता को सीमित करने से स्पष्ट गति * गिरावट नहीं होती है
  *गति = औसत [जल्दी रुकने तक का समय/जल्दी रुकने तक बूस्टिंग पुनरावृत्तियों की संख्या]

no constraint: 964.9 microseconds per iteration
with constraint: 861.7 microseconds per iteration

(कृपया टिप्पणी करें कि क्या आपके पास गति परीक्षण करने का बेहतर तरीका है)

• गैर-मोनोटोनिक चर के लिए दिशा को बाधित करते समय सावधान रहने की आवश्यकता है। इससे प्रदर्शन में गिरावट आ सकती है।
• विभिन्न हाइपर-पैरामीटर के आसपास खेलते समय Check failed: (wleft) <= (wright) कारण कोड क्रैश देखना।

मैंने ज्यूपिटर नोटबुक में कुछ समय के प्रयोग चलाए।

पहला परीक्षण: कुछ सरल नकली डेटा। दो विशेषताएं हैं, एक बढ़ती और एक घटती, लेकिन एक छोटी साइनसॉइडल तरंग के साथ आरोपित किया जाता है ताकि प्रत्येक विशेषता वास्तव में एकरस न हो

X = np.random.random(size=(N, K))
y = (5*X[:, 0] + np.sin(5*2*pi*X[:, 0])
     - 5*X[:, 1] - np.cos(5*2*pi*X[:, 1])
     + np.random.normal(loc=0.0, scale=0.01, size=N))

मोनोटोन बाधाओं के साथ और बिना xgboosts के समय परिणाम यहां दिए गए हैं। मैंने जल्दी रुकना बंद कर दिया और प्रत्येक के लिए पुनरावृत्तियों की एक निर्धारित संख्या को बढ़ाया।

मोनोटोन बाधाओं के बिना पहला:

%%timeit -n 100
model_no_constraints = xgb.train(params, dtrain, 
                                 num_boost_round = 2500, 
                                 verbose_eval = False)

100 loops, best of 3: 246 ms per loop

और यहाँ एकरसता की कमी के साथ

%%timeit -n 100
model_with_constraints = xgb.train(params_constrained, dtrain, 
                                 num_boost_round = 2500, 
                                 verbose_eval = False)

100 loops, best of 3: 196 ms per loop

दूसरा परीक्षण: कैलिफ़ोर्निया एचहाउसिंग डेटा स्केलेर से। बाधाओं के बिना

%%timeit -n 10
model_no_constraints = xgb.train(params, dtrain, 
                                 num_boost_round = 2500, 
                                 verbose_eval = False)

10 loops, best of 3: 5.9 s per loop

यहां वे बाधाएं हैं जिनका मैंने उपयोग किया है

print(params_constrained['monotone_constraints'])

(1,1,1,0,0,1,0,0)

और विवश मॉडल के लिए समय

%%timeit -n 10
model_no_constraints = xgb.train(params, dtrain, 
                                 num_boost_round = 2500, 
                                 verbose_eval = False)

10 loops, best of 3: 6.08 s per loop

@ XiaoxiaoWang87 मैंने एक और पीआर को वेले और राइट पर चेक को ढीला करने के लिए धक्का दिया है, कृपया देखें कि यह काम करता है।
@madrury क्या आप बिना किसी बाधा सुविधा के XGBoost के पिछले संस्करण से तुलना कर सकते हैं?

@tqchen ज़रूर। क्या आप तुलना करने के लिए प्रतिबद्ध हैश की सिफारिश कर सकते हैं? क्या मुझे मोनोटोन बाधाओं को जोड़ने से पहले केवल प्रतिबद्धता का उपयोग करना चाहिए?

हाँ पिछला वाला करेगा

@tqchen अद्यतन संस्करण के पुनर्निर्माण पर, मुझे कुछ त्रुटियां मिल रही हैं जो मेरे पास पहले नहीं थीं। मुझे उम्मीद है कि कारण आप पर स्पष्ट रूप से कूदता है।

यदि मैं पहले जैसा ही कोड चलाने का प्रयास करता हूं, तो मुझे अपवाद मिल रहा है, यहां पूर्ण ट्रेसबैक है:

XGBoostError                              Traceback (most recent call last)
<ipython-input-14-63a9f6e16c9a> in <module>()
      8    model_with_constraints = xgb.train(params, dtrain, 
      9                                        num_boost_round = 1000, evals = evallist,
---> 10                                    early_stopping_rounds = 10)  

/Users/matthewdrury/anaconda/lib/python2.7/site-packages/xgboost-0.6-py2.7.egg/xgboost/training.pyc in train(params, dtrain, num_boost_round, evals, obj, feval, maximize, early_stopping_rounds, evals_result, verbose_eval, learning_rates, xgb_model, callbacks)
    201                            evals=evals,
    202                            obj=obj, feval=feval,
--> 203                            xgb_model=xgb_model, callbacks=callbacks)
    204 
    205 

/Users/matthewdrury/anaconda/lib/python2.7/site-packages/xgboost-0.6-py2.7.egg/xgboost/training.pyc in _train_internal(params, dtrain, num_boost_round, evals, obj, feval, xgb_model, callbacks)
     72         # Skip the first update if it is a recovery step.
     73         if version % 2 == 0:
---> 74             bst.update(dtrain, i, obj)
     75             bst.save_rabit_checkpoint()
     76             version += 1

/Users/matthewdrury/anaconda/lib/python2.7/site-packages/xgboost-0.6-py2.7.egg/xgboost/core.pyc in update(self, dtrain, iteration, fobj)
    804 
    805         if fobj is None:
--> 806             _check_call(_LIB.XGBoosterUpdateOneIter(self.handle, iteration, dtrain.handle))
    807         else:
    808             pred = self.predict(dtrain)

/Users/matthewdrury/anaconda/lib/python2.7/site-packages/xgboost-0.6-py2.7.egg/xgboost/core.pyc in _check_call(ret)
    125     """
    126     if ret != 0:
--> 127         raise XGBoostError(_LIB.XGBGetLastError())
    128 
    129 

XGBoostError: [14:08:41] src/tree/tree_updater.cc:18: Unknown tree updater grow_monotone_colmaker

अगर मैं आपके द्वारा लागू किए गए कीवर्ड तर्क के लिए सब कुछ बदल देता हूं तो मुझे भी एक त्रुटि मिलती है:

TypeError                                 Traceback (most recent call last)
<ipython-input-15-ef7671f72925> in <module>()
      8                                    monotone_constraints="(1)",
      9                                    num_boost_round = 1000, evals = evallist,
---> 10                                    early_stopping_rounds = 10)  

TypeError: train() got an unexpected keyword argument 'monotone_constraints'

अद्यतनकर्ता तर्क को हटा दें और मोनोटोन बाधा तर्कों को मापदंडों में रखें, अब जब मोनोटोन बाधाएँ प्रस्तुत की जाती हैं तो मोनोटोन बाधा अद्यतनकर्ता स्वचालित रूप से सक्रिय हो जाता है

@tqchen मेरे दोस्त @amontz ने मुझे संदेश पोस्ट करने के तुरंत बाद यह पता लगाने में मदद की। मैंने आपकी टिप्पणी की व्याख्या monotone_constraints को kwarg के रूप में .train ।

यह उन समायोजनों के साथ काम करता है। धन्यवाद।

@madrury क्या आप गति की पुष्टि कर सकते हैं?

इसके अलावा @madrury और @ XiaoxiaoWang87 चूंकि यह सुविधा अब विलय के करीब है, यह बहुत अच्छा होगा यदि आप उपयोगकर्ताओं के लिए इस सुविधा को पेश करने वाला एक ट्यूटोरियल बनाने के लिए समन्वय कर सकते हैं।

हम ipy नोटबुक को सीधे मुख्य रेपो में नहीं ले जा सकते। लेकिन छवियों को https://github.com/dmlc/web-data/tree/master/xgboost पर धकेला जा सकता है और मुख्य रेपो पर मार्कडाउन किया जा सकता है।

हमें फ्रंट-एंड इंटरफ़ेस स्ट्रिंग रूपांतरण को भी बदलने की आवश्यकता है, ताकि इंट टपल को स्ट्रिंग टपल प्रारूप में परिवर्तित किया जा सके जिसे बैकएंड द्वारा स्वीकार किया जा सके।

@ hetong007 R में बदलाव के लिए और @slundberg जूलिया के लिए

@tqchen जूलिया वर्तमान में XGBoost के 0.4 संस्करण से जुड़ी हुई है, इसलिए अगली बार मुझे इसका उपयोग करने की आवश्यकता है और समय अलग रखा गया है, अगर किसी और के पास नहीं है तो मैं बाइंडिंग को अपडेट कर दूंगा। उस समय यह बदलाव भी जुड़ सकता है।

कार्यान्वयन से पहले से बाद में एक मोनोटोन बाधा मॉडल _बिना_के बीच तुलना यहां दी गई है।

प्रतिबद्ध 8cac37 : मोनोटोन बाधा के कार्यान्वयन से पहले।'
नकली डेटा : 100 loops, best of 3: 232 ms per loop
कैलिफ़ोर्निया डेटा : 10 loops, best of 3: 5.89 s per loop

प्रतिबद्ध b1c224 : मोनोटोन बाधा के कार्यान्वयन के बाद।
नकली डेटा : 100 loops, best of 3: 231 ms per loop
कैलिफ़ोर्निया डेटा : 10 loops, best of 3: 5.61 s per loop

कार्यान्वयन के बाद कैलिफ़ोर्निया के लिए गति मुझे संदिग्ध लगती है, लेकिन मैंने इसे हर तरह से दो बार करने की कोशिश की, और यह सुसंगत है।

मुझे एक ट्यूटोरियल लिखने में एक शॉट लेने में खुशी होगी। मैं मौजूदा दस्तावेज़ों को देखूंगा और अगले कुछ दिनों में कुछ एक साथ रखूंगा।

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

धन्यवाद @madrury। इंतज़ार करूंगा। मुझे बताएं कि मैं क्या मदद कर सकता हूं। मैं निश्चित रूप से इस विषय पर और अध्ययन करने के लिए तैयार हूं।

मैं कल इसे बढ़ाऊंगा। मैं सिर्फ एक सरणी के बजाय एक स्ट्रिंग के माध्यम से सी ++ के साथ संचार करने के कारण के बारे में उत्सुक हूं।

मैं आर से परीक्षण कर रहा हूं। मैंने यादृच्छिक रूप से दो-चर डेटा उत्पन्न किया और भविष्यवाणी करने का प्रयास किया।

हालांकि, मैंने पाया कि

1. xgboost भविष्यवाणी को बाधित नहीं करता है।
2. पैरामीटर monotone_constraints भविष्यवाणी को थोड़ा अलग बनाता है।

कृपया इसे इंगित करें यदि मैंने कोई गलती की है।

इसे पुन: पेश करने के लिए कोड ( नवीनतम जीथब संस्करण पर परीक्षण किया गया, drat ):

set.seed(1024)
x1 = rnorm(1000, 10)
x2 = rnorm(1000, 10)
y = -1*x1 + rnorm(1000, 0.001) + 3*sin(x2)
train = cbind(x1, x2)

bst = xgboost(data = train, label = y, max_depth = 2,
                   eta = 0.1, nthread = 2, nrounds = 10,
                   monotone_constraints = '(1,-1)')

pred = predict(bst, train)
ind = order(train[,1])
pred.ord = pred[ind]
plot(train[,1], y, main = 'with constraint')
pred.ord = pred[order(train[,1])]
lines(pred.ord)

bst = xgboost(data = train, label = y, max_depth = 2,
                   eta = 0.1, nthread = 2, nrounds = 10)

pred = predict(bst, train)
ind = order(train[,1])
pred.ord = pred[ind]
plot(train[,1], y, main = 'without constraint')
pred.ord = pred[order(train[,1])]
lines(pred.ord)

बाधा आंशिक आदेश पर की गई थी। तो बाधा तभी लागू होती है जब हम अन्य अक्ष को स्थिर रखते हुए मोनटोन अक्ष को आगे बढ़ा रहे हों

@ hetong007 मेरे प्लॉट बनाने के लिए I

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

यहां पाइथन कोड है जिसे मैंने ऊपर शामिल भूखंडों के लिए उपयोग किया है, इसे आसानी से समकक्ष आर कोड में परिवर्तित करना चाहिए।

def plot_one_feature_effect(model, X, y, idx=1):

    x_scan = np.linspace(0, 1, 100)    
    X_scan = np.empty((100, X.shape[1]))
    X_scan[:, idx] = x_scan

    left_feature_means = np.tile(X[:, :idx].mean(axis=0), (100, 1))
    right_feature_means = np.tile(X[:, (idx+1):].mean(axis=0), (100, 1))
    X_scan[:, :idx] = left_feature_means
    X_scan[:, (idx+1):] = right_feature_means

    X_plot = xgb.DMatrix(X_scan)
    y_plot = model.predict(X_plot, ntree_limit=bst.best_ntree_limit)

    plt.plot(x_scan, y_plot, color = 'black')
    plt.plot(X[:, idx], y, 'o', alpha = 0.25)

यहां बताया गया है कि मैं आंशिक निर्भरता भूखंड कैसे करता हूं (एक मनमाना मॉडल के लिए):

• फ़ीचर X के लिए मानों का ग्रिड स्कैन करें।
• सुविधा X के प्रत्येक ग्रिड मान के लिए:
  
  
  
  • इस मान पर संपूर्ण सुविधा X कॉलम (सभी पंक्तियाँ) सेट करें। अन्य विशेषताएं अपरिवर्तित।
  
  
  • सभी पंक्तियों के लिए भविष्यवाणियां करें।
  
  
  • भविष्यवाणी का औसत लें।
  
  
• परिणामी (एक्स फीचर वैल्यू, औसत भविष्यवाणी) जोड़े आपको एक्स फीचर आंशिक निर्भरता देते हैं।

कोड:

def plot_partial_dependency(bst, X, y, f_id):

    X_temp = X.copy()

    x_scan = np.linspace(np.percentile(X_temp[:, f_id], 0.1), np.percentile(X_temp[:, f_id], 99.5), 50)
    y_partial = []

    for point in x_scan:

        X_temp[:, f_id] = point

        dpartial = xgb.DMatrix(X_temp[:, feature_ids])
        y_partial.append(np.average(bst.predict(dpartial)))

    y_partial = np.array(y_partial)

    # Plot partial dependence

    fig, ax = plt.subplots()
    fig.set_size_inches(5, 5)
    plt.subplots_adjust(left = 0.17, right = 0.94, bottom = 0.15, top = 0.9)

    ax.plot(x_scan, y_partial, '-', color = 'black', linewidth = 1)
    ax.plot(X[:, f_id], y, 'o', color = 'blue', alpha = 0.02)

    ax.set_xlim(min(x_scan), max(x_scan))
    ax.set_xlabel('Feature X', fontsize = 10)    
    ax.set_ylabel('Partial Dependence', fontsize = 12)

मार्गदर्शन के लिए धन्यवाद! मुझे एहसास हुआ कि मैंने साजिश में मूर्खतापूर्ण गलती की है। यहाँ एक अविभाज्य डेटा पर एक और परीक्षण है, कथानक ठीक लगता है:

set.seed(1024)
x = rnorm(1000, 10)
y = -1*x + rnorm(1000, 0.001) + 3*sin(x)
train = matrix(x, ncol = 1)

bst = xgboost(data = train, label = y, max_depth = 2,
               eta = 0.1, nthread = 2, nrounds = 100,
               monotone_constraints = '(-1)')
pred = predict(bst, train)
ind = order(train[,1])
pred.ord = pred[ind]
plot(train[,1], y, main = 'with constraint', pch=20)
lines(train[ind,1], pred.ord, col=2, lwd = 5)

bst = xgboost(data = train, label = y, max_depth = 2,
               eta = 0.1, nthread = 2, nrounds = 100)
pred = predict(bst, train)
ind = order(train[,1])
pred.ord = pred[ind]
plot(train[,1], y, main = 'without constraint', pch=20)
lines(train[ind,1], pred.ord, col=2, lwd = 5)

@ hetong007 तो आर इंटरफ़ेस में लक्ष्य उपयोगकर्ता को स्ट्रिंग के अलावा आर सरणी में पास करने में सक्षम बनाना है

monotone_constraints=c(1,-1)

कृपया हमें बताएं कि आप ट्यूटोरियल के पीआर कब हैं

@ hetong007 r-blogger संस्करण बनाने के लिए आपका भी स्वागत है

@tqchen क्षमा करें दोस्तों, मैं सप्ताह के लिए एक कार्य यात्रा पर हूं।

मैंने एक मोनोटोनिक बाधा ट्यूटोरियल के लिए कुछ पुल अनुरोध भेजे। कृपया मुझे बताएं कि आप क्या सोचते हैं, मैं किसी भी आलोचना या आलोचना से खुश हूं।

उम्मीद है कि यहां यह पूछना उचित होगा: क्या यह अब काम करेगा यदि हम सामान्य git clone --recursive https://github.com/dmlc/xgboost का उपयोग करके अपडेट करते हैं?

मैं पूछता हूं कि मैंने नया ट्यूटोरियल देखा है लेकिन कोड में बदलाव के बारे में कुछ भी नया नहीं है। आप सभी को धन्यवाद!

हाँ, ट्यूटोरियल के विलय से पहले नई सुविधा को मिला दिया गया है

नमस्ते,

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

एकरसता को तोड़ने का एक सरल उदाहरण यहां दिया गया है:

`
df <- data.frame(y = c(2,rep(6,100),1,rep(11,100)),
x1= c(rep(1,101),rep(2,101)),x2 = c(1,rep(2,100),1,rep(2,100)))

पुस्तकालय (xgboost)
सेट.बीज(0)
XGB <- xgboost(data=data.matrix(df[,-1]),label=df[,1],
उद्देश्य = " रेग: रैखिक ",
बैग.अंश = 1, चारों ओर = 100, monotone_constraints=c(10),
एटा = 0.1 )

sans_corr <- data.frame(x1=c(1,2,1,2),x2=c(1,1,2,2))

sans_corr$prediction <- भविष्यवाणी करें(XGB,data.matrix(sans_corr))
`

आशा है कि आपके कोड की मेरी समझ और मेरा उदाहरण गलत नहीं है

वर्तमान में यह सुविधा Sklearn api में नहीं है। क्या आप या कोई कृपया इसे जोड़ने में मदद कर सकता है? धन्यवाद!

एक चर पर सामान्य एकरसता को लागू करना संभव है, यह निर्दिष्ट किए बिना कि इसे बढ़ाना चाहिए या घटाना चाहिए?

@davidADSP आप वांछित भविष्यवक्ता पर एक स्पीयरमैन सहसंबंध जांच कर सकते हैं और यह देखने के लिए लक्ष्य बना सकते हैं कि बढ़ना या घटाना उचित है या नहीं।

यह सुविधा अमान्य प्रतीत होती है जब 'tree_method':'hist'। @tqchen कोई मदद? सबको शुक्रीया।

mlogloss जैसे मल्टीक्लास उद्देश्य के लिए बाधा कैसे काम करती है? क्या मोनोटोनिसिटी बाधा मल्टीक्लास नुकसान के लिए समर्थित है? यदि हां, तो इसे कैसे लागू किया जाता है। (जैसा कि प्रत्येक वर्ग के लिए एक पेड़ है)

क्या XGBOOST में लागू मोनोसिटी एल्गोरिथम पर कोई श्वेतपत्र है? ग्लोबल है या लोकल? स्थानीय मतलब कुछ नोड्स के लिए विशिष्ट लेकिन पेड़ के अन्य हिस्सों में नोड्स समग्र एकरसता का उल्लंघन पैदा कर सकते हैं। क्या कोई कृपया L412-417 लाइन को समझने में मेरी मदद कर सकता है। क्यों "w" घिरा हुआ है- ऊपरी और निचला। यह कैसे एकरसता बनाए रखने में मदद करता है। पंक्ति 457 - "मध्य" का प्रयोग क्यों किया जाता है?