Xgboost: [आर] मॉडल को डिस्क पर सहेजे जाने पर शुरुआती रोक से सर्वश्रेष्ठ पुनरावृत्ति सूचकांक को छोड़ दिया जाता है

बाइनरी या जोंस दोनों के लिए कोई गोल त्रुटि नहीं होनी चाहिए। क्या आप डार्ट का उपयोग कर रहे हैं?

नहीं में नहीं हूँ:

params <- list(objective = 'reg:squarederror',
               max_depth = 10, eta = 0.02, subsammple = 0.5,
               base_score = median(xgboost::getinfo(xgb.train, 'label'))
)

xgboost::xgb.train(
  params = params, data = xgb.train,
  watchlist = list('train' = xgb.train, 'test' = xgb.test),
  nrounds = 10000, verbose = TRUE, print_every_n = 25,
  eval_metric = 'mae',
  early_stopping_rounds = 3, maximize = FALSE)

क्या आप हमें डमी डेटा प्रदान कर सकते हैं जहां यह घटना होती है?

यहाँ तुम जाओ (त्वरित और गंदा):

N <- 100000
set.seed(2020)
X <- data.frame('X1' = rnorm(N), 'X2' = runif(N), 'X3' = rpois(N, lambda = 1))
Y <- with(X, X1 + X2 - X3 + X1*X2^2 - ifelse(X1 > 0, 2, X3))

params <- list(objective = 'reg:squarederror',
               max_depth = 5, eta = 0.02, subsammple = 0.5,
               base_score = median(Y)
)

dtrain <- xgboost::xgb.DMatrix(data = data.matrix(X), label = Y)

fit <- xgboost::xgb.train(
  params = params, data = dtrain,
  watchlist = list('train' = dtrain),
  nrounds = 10000, verbose = TRUE, print_every_n = 25,
  eval_metric = 'mae',
  early_stopping_rounds = 3, maximize = FALSE
)

pred <- stats::predict(fit, newdata = dtrain)

xgboost::xgb.save(fit, 'booster.raw')
fit.loaded <- xgboost::xgb.load('booster.raw')

pred.loaded <- stats::predict(fit.loaded, newdata = dtrain)

identical(pred, pred.loaded)
pred[1:10]
pred.loaded[1:10]

sqrt(mean((Y - pred)^2))
sqrt(mean((Y - pred.loaded)^2))

मेरी मशीन पर, identical(pred, pred.loaded) गलत है (यानी सच होना चाहिए)। यहाँ अंतिम आदेशों का आउटपुट है:

> identical(pred, pred.loaded)
[1] FALSE
> pred[1:10]
 [1] -4.7971768 -2.5070562 -0.8889422 -4.9199696 -4.4374819 -0.2739395 -0.9825708  0.4579227  1.3667605 -4.3333349
> pred.loaded[1:10]
 [1] -4.7971768 -2.5070562 -0.8889424 -4.9199696 -4.4373770 -0.2739397 -0.9825710  0.4579227  1.3667605 -4.3333349
> 
> sqrt(mean((Y - pred)^2))
[1] 0.02890702
> sqrt(mean((Y - pred.loaded)^2))
[1] 0.02890565

आप देखते हैं कि भविष्यवाणियां कभी-कभी थोड़ी भिन्न होती हैं। क्या आप अपनी मशीन पर उदाहरण कोड को फिर से चला सकते हैं और देख सकते हैं कि क्या इसमें वही समस्या है?

R और xgboost के बारे में कुछ अतिरिक्त जानकारी:

> sessionInfo()
R version 3.6.1 (2019-07-05)
Platform: x86_64-w64-mingw32/x64 (64-bit)
Running under: Windows >= 8 x64 (build 9200)

Matrix products: default

locale:
[1] LC_COLLATE=English_United States.1252  LC_CTYPE=English_United States.1252    LC_MONETARY=English_United States.1252 LC_NUMERIC=C                          
[5] LC_TIME=English_United States.1252    

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

loaded via a namespace (and not attached):
 [1] compiler_3.6.1    magrittr_1.5      Matrix_1.2-17     tools_3.6.1       yaml_2.2.0        xgboost_0.90.0.2  stringi_1.4.3     grid_3.6.1       
 [9] data.table_1.12.4 lattice_0.20-38 

यह भी ध्यान दें कि:

> identical(fit$raw, fit.loaded$raw)
[1] TRUE

स्क्रिप्ट के लिए धन्यवाद। बस एक अपडेट, मैंने इसे जेसन और बाइनरी फ़ाइल में सहेजने के साथ चलाया:

xgboost::xgb.save(fit, 'booster.json')
fit.loaded <- xgboost::xgb.load('booster.json')

xgboost::xgb.save(fit.loaded, 'booster-1.json')

booster.json और booster-1.json हैश मान (via sha256sum ./booster.json ) बिल्कुल समान हैं, इसलिए मेरा अनुमान है कि कहीं न कहीं फ़्लोटिंग पॉइंट अंकगणित के कारण विसंगति है।

बिना कारण जाने मामले को बंद क्यों करें?

@ट्रिवियलफिस क्या आपको identical(pred, pred.loaded) लिए सही मिला? ओपी पूछ रहा है कि भविष्यवाणियां क्यों मेल नहीं खातीं, भले ही दो मॉडलों में समान बाइनरी हस्ताक्षर हों।

मैं इसे स्वयं पुन: पेश करने का प्रयास करूंगा।

मुझे माफ करें। मुझे जो कारण मिला वह भविष्यवाणी कैश है। मॉडल को लोड करने के बाद, कैश्ड वैल्यू के बजाय भविष्यवाणी मान सही भविष्यवाणी से आते हैं:

तो मेरा अनुमान है कि कहीं न कहीं फ़्लोटिंग पॉइंट अंकगणित के कारण विसंगति है।

तो भविष्यवाणी कैश फ्लोटिंग-पॉइंट अंकगणित के साथ विनाशकारी तरीके से बातचीत करता है?

@ hcho3 नई अचार बनाने की विधि को लागू करने के दौरान मुझे यह एक समस्या मिली। मेरा मानना ​​है कि यह यहां एक प्रमुख भूमिका निभाता है। इसलिए पहले पेड़ों की संख्या घटाकर 1000 कर दें (जो अभी भी बहुत बड़ा है और डेमो के लिए पर्याप्त होना चाहिए)।

कैश को रास्ते से हटाने के लिए भविष्यवाणी से पहले DMatrix का पुन: निर्माण करें:

dtrain_2 <- xgboost::xgb.DMatrix(data = data.matrix(X), label = Y)

pred <- stats::predict(fit, newdata = dtrain_2)

यह identical परीक्षा पास करेगा। अन्यथा यह विफल हो जाता है।

अधिक पेड़ों में समान परीक्षण में अभी भी छोटे अंतर हैं (2000 पेड़ों के लिए 1e-7)। लेकिन क्या हमें बहु-थ्रेडेड वातावरण में भी थोड़ा समान परिणाम देने की आवश्यकता है?

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

वास्तव में आदेश के लिए मजबूत गारंटी देने से काम नहीं चलेगा (बहुत मदद मिलेगी लेकिन फिर भी विसंगति होगी)। सीपीयू एफपीयू रजिस्टर में एक फ़्लोटिंग पॉइंट में उच्च परिशुद्धता हो सकती है और फिर स्मृति में संग्रहीत की जा सकती है। (हार्डवेयर कार्यान्वयन इंटरमीडिया मूल्यों के लिए उच्च परिशुद्धता का उपयोग कर सकता है, https://en.wikipedia.org/wiki/Extended_precision)। मेरा मुद्दा यह है कि जब 32 बिट फ्लोट के भीतर 1000 पेड़ों का परिणाम बिल्कुल पुन: उत्पन्न होता है, तो यह प्रोग्रामिंग बग की संभावना नहीं है।

मैं सहमत हूं कि फ्लोटिंग-पॉइंट योग सहयोगी नहीं है। मैं स्वयं स्क्रिप्ट चलाऊंगा और देखूंगा कि क्या अंतर फ़्लोटिंग-पॉइंट अंकगणित के लिए विशेषता के लिए काफी छोटा है।

आम तौर पर, मैं आमतौर पर np.testing.assert_almost_equal साथ decimal=5 का उपयोग यह जांचने के लिए करता हूं कि दो फ्लोट सरणी एक दूसरे के बराबर हैं या नहीं।

हाँ। विस्तृत नोट्स के बिना बंद करने के लिए क्षमा याचना।

@ hcho3 कोई अपडेट?

मैं अभी तक इसके आसपास नहीं गया हूं। मुझे इस सप्ताह एक नज़र डालने दो।

@ट्रिवियलफिस मैं बग को पुन: पेश करने में कामयाब रहा। मैंने प्रदान की गई स्क्रिप्ट को चलाया और FALSE लिए identical(pred, pred.loaded) । मैंने आपके सुझाव के अनुसार एक नया DMatrix dtrain_2 बनाने का प्रयास किया और अभी भी परीक्षण के लिए FALSE प्राप्त किया।

@DavorJ की स्क्रिप्ट से आउटपुट:

[1] FALSE     # identical(pred, pred.loaded)
 [1] -4.7760534 -2.5083885 -0.8860036 -4.9163256 -4.4455137 -0.2548684
 [7] -0.9745615  0.4646015  1.3602829 -4.3288369     # pred[1:10]
 [1] -4.7760534 -2.5083888 -0.8860038 -4.9163256 -4.4454765 -0.2548686
 [7] -0.9745617  0.4646015  1.3602829 -4.3288369     # pred.loaded[1:10]
[1] 0.02456085   # MSE on pred
[1] 0.02455945   # MSE on pred.loaded

dtrain_2 <- xgboost::xgb.DMatrix(data = data.matrix(X), label = Y) साथ संशोधित स्क्रिप्ट से आउटपुट:

[1] FALSE     # identical(pred, pred.loaded)
 [1] -4.7760534 -2.5083885 -0.8860036 -4.9163256 -4.4455137 -0.2548684
 [7] -0.9745615  0.4646015  1.3602829 -4.3288369     # pred[1:10]
 [1] -4.7760534 -2.5083888 -0.8860038 -4.9163256 -4.4454765 -0.2548686
 [7] -0.9745617  0.4646015  1.3602829 -4.3288369     # pred.loaded[1:10]
[1] 0.02456085   # MSE on pred
[1] 0.02455945   # MSE on pred.loaded

तो कुछ और चल रहा होगा।

मैंने राउंड-ट्रिप टेस्ट चलाने की भी कोशिश की:

xgboost::xgb.save(fit, 'booster.raw')
fit.loaded <- xgboost::xgb.load('booster.raw')
xgboost::xgb.save(fit.loaded, 'booster.raw.roundtrip')

और दो बाइनरी फ़ाइलें booster.raw और booster.raw.roundtrip समान थीं।

pred और pred.loaded बीच अधिकतम अंतर 0.0008370876 है।

एक छोटा उदाहरण जो तेजी से चलता है:

library(xgboost)

N <- 5000
set.seed(2020)
X <- data.frame('X1' = rnorm(N), 'X2' = runif(N), 'X3' = rpois(N, lambda = 1))
Y <- with(X, X1 + X2 - X3 + X1*X2^2 - ifelse(X1 > 0, 2, X3))

params <- list(objective = 'reg:squarederror',
               max_depth = 5, eta = 0.02, subsammple = 0.5,
               base_score = median(Y)
)

dtrain <- xgboost::xgb.DMatrix(data = data.matrix(X), label = Y)

fit <- xgboost::xgb.train(
  params = params, data = dtrain,
  watchlist = list('train' = dtrain),
  nrounds = 10000, verbose = TRUE, print_every_n = 25,
  eval_metric = 'mae',
  early_stopping_rounds = 3, maximize = FALSE
)

pred <- stats::predict(fit, newdata = dtrain)

invisible(xgboost::xgb.save(fit, 'booster.raw'))
fit.loaded <- xgboost::xgb.load('booster.raw')
invisible(xgboost::xgb.save(fit.loaded, 'booster.raw.roundtrip'))

pred.loaded <- stats::predict(fit.loaded, newdata = dtrain)

identical(pred, pred.loaded)
pred[1:10]
pred.loaded[1:10]
max(abs(pred - pred.loaded))

sqrt(mean((Y - pred)^2))
sqrt(mean((Y - pred.loaded)^2))

आउटपुट:

[1] FALSE
 [1] -2.4875379 -0.9452241 -6.9658904 -2.9985323 -4.2192593 -0.8505422
 [7] -0.3928839 -1.6886091 -1.3611379 -3.1278882
 [1] -2.4875379 -0.9452239 -6.9658904 -2.9985323 -4.2192593 -0.8505420
 [7] -0.3928837 -1.6886090 -1.3611377 -3.1278882
[1] 0.0001592636
[1] 0.01370754
[1] 0.01370706

बस एक अतिरिक्त राउंड-ट्रिप करने की कोशिश की, और अब भविष्यवाणियां और नहीं बदलती हैं।

library(xgboost)

N <- 5000
set.seed(2020)
X <- data.frame('X1' = rnorm(N), 'X2' = runif(N), 'X3' = rpois(N, lambda = 1))
Y <- with(X, X1 + X2 - X3 + X1*X2^2 - ifelse(X1 > 0, 2, X3))

params <- list(objective = 'reg:squarederror',
               max_depth = 5, eta = 0.02, subsammple = 0.5,
               base_score = median(Y)
)

dtrain <- xgboost::xgb.DMatrix(data = data.matrix(X), label = Y)

fit <- xgboost::xgb.train(
  params = params, data = dtrain,
  watchlist = list('train' = dtrain),
  nrounds = 10000, verbose = TRUE, print_every_n = 25,
  eval_metric = 'mae',
  early_stopping_rounds = 3, maximize = FALSE
)

pred <- stats::predict(fit, newdata = dtrain)

invisible(xgboost::xgb.save(fit, 'booster.raw'))
fit.loaded <- xgboost::xgb.load('booster.raw')
invisible(xgboost::xgb.save(fit.loaded, 'booster.raw.roundtrip'))
fit.loaded2 <- xgboost::xgb.load('booster.raw.roundtrip')

pred.loaded <- stats::predict(fit.loaded, newdata = dtrain)
pred.loaded2 <- stats::predict(fit.loaded2, newdata = dtrain)

identical(pred, pred.loaded)
identical(pred.loaded, pred.loaded2)
pred[1:10]
pred.loaded[1:10]
pred.loaded2[1:10]
max(abs(pred - pred.loaded))
max(abs(pred.loaded - pred.loaded2))

sqrt(mean((Y - pred)^2))
sqrt(mean((Y - pred.loaded)^2))
sqrt(mean((Y - pred.loaded2)^2))

नतीजा:

[1] FALSE
[1] TRUE
 [1] -2.4875379 -0.9452241 -6.9658904 -2.9985323 -4.2192593 -0.8505422
 [7] -0.3928839 -1.6886091 -1.3611379 -3.1278882
 [1] -2.4875379 -0.9452239 -6.9658904 -2.9985323 -4.2192593 -0.8505420
 [7] -0.3928837 -1.6886090 -1.3611377 -3.1278882
 [1] -2.4875379 -0.9452239 -6.9658904 -2.9985323 -4.2192593 -0.8505420
 [7] -0.3928837 -1.6886090 -1.3611377 -3.1278882
[1] 0.0001592636
[1] 0
[1] 0.01370754
[1] 0.01370706
[1] 0.01370706

तो शायद भविष्यवाणी कैश वास्तव में एक समस्या है।

मैंने भविष्यवाणी कैशिंग अक्षम के साथ स्क्रिप्ट को फिर से चलाया:

diff --git a/src/predictor/cpu_predictor.cc b/src/predictor/cpu_predictor.cc
index ebc15128..c40309bc 100644
--- a/src/predictor/cpu_predictor.cc
+++ b/src/predictor/cpu_predictor.cc
@@ -259,7 +259,7 @@ class CPUPredictor : public Predictor {
     // delta means {size of forest} * {number of newly accumulated layers}
     uint32_t delta = end_version - beg_version;
     CHECK_LE(delta, model.trees.size());
-    predts->Update(delta);
+    //predts->Update(delta);

     CHECK(out_preds->Size() == output_groups * dmat->Info().num_row_ ||
           out_preds->Size() == dmat->Info().num_row_);

(पूर्वानुमान कैशिंग को अक्षम करने से बहुत धीमी गति से प्रशिक्षण प्राप्त होता है।)

आउटपुट:

[1] FALSE
[1] TRUE
 [1] -2.4908853 -0.9507379 -6.9615889 -2.9935317 -4.2165089 -0.8543566
 [7] -0.3940181 -1.6930715 -1.3572118 -3.1403396
 [1] -2.4908853 -0.9507380 -6.9615889 -2.9935317 -4.2165089 -0.8543567
 [7] -0.3940183 -1.6930716 -1.3572119 -3.1403399
 [1] -2.4908853 -0.9507380 -6.9615889 -2.9935317 -4.2165089 -0.8543567
 [7] -0.3940183 -1.6930716 -1.3572119 -3.1403399
[1] 0.0001471043
[1] 0
[1] 0.01284297
[1] 0.01284252
[1] 0.01284252

तो भविष्यवाणी कैश निश्चित रूप से इस बग का कारण नहीं है।

पत्ता भविष्यवाणियां भी भिन्न होती हैं:

invisible(xgboost::xgb.save(fit, 'booster.raw'))
fit.loaded <- xgboost::xgb.load('booster.raw')
invisible(xgboost::xgb.save(fit.loaded, 'booster.raw.roundtrip'))
fit.loaded2 <- xgboost::xgb.load('booster.raw.roundtrip')

x <- predict(fit, newdata = dtrain2, predleaf = TRUE)
x2 <- predict(fit.loaded, newdata = dtrain2, predleaf = TRUE)
x3 <- predict(fit.loaded2, newdata = dtrain2, predleaf = TRUE)

identical(x, x2)
identical(x2, x3)

आउटपुट:

[1] FALSE
[1] TRUE

रहस्य सुलझ गया। मैंने सही कारण की पहचान की। जब मॉडल को डिस्क पर सहेजा जाता है, तो जल्दी रुकने की जानकारी छोड़ दी जाती है। उदाहरण में, XGBoost 6381 बूस्टिंग राउंड चलाता है और 6378 राउंड में सबसे अच्छा मॉडल ढूंढता है। मेमोरी में मॉडल ऑब्जेक्ट में 6381 पेड़ हैं, न कि 6378 पेड़, क्योंकि कोई पेड़ नहीं हटाया गया है। एक अतिरिक्त फ़ील्ड है best_iteration जो याद रखता है कि कौन सा पुनरावृत्ति सबसे अच्छा था:

> fit$best_iteration
[1] 6378

जब हम मॉडल को डिस्क पर सहेजते हैं तो यह अतिरिक्त फ़ील्ड चुपचाप हटा दी जाती है। तो मूल मॉडल के साथ predict() 6378 पेड़ों का उपयोग करता है, जबकि predict() बरामद मॉडल के साथ 6381 पेड़ों का उपयोग करता है।

> x <- predict(fit, newdata = dtrain2, predleaf = TRUE)
> x2 <- predict(fit.loaded, newdata = dtrain2, predleaf = TRUE)
> dim(x)
[1] 5000 6378
> dim(x2)
[1] 5000 6381

@ट्रिवियलफिस मैं पेड़ों को शारीरिक रूप से हटाने के लिए इच्छुक हूं। यदि प्रशिक्षण 6381 राउंड पर रुक गया और सबसे अच्छा पुनरावृत्ति 6378 राउंड पर था, तो उपयोगकर्ता उम्मीद करेंगे कि अंतिम मॉडल में 6378 पेड़ होंगे।

@ hcho3 मुझे लगता है कि यह https://github.com/dmlc/xgboost/issues/4052 में एक समान समस्या है।

bset_iteration को Learner::attributes_ में सहेजा जाना चाहिए, जिसे xgboost::xgb.attr माध्यम से एक्सेस किया जा सकता है।

@ hcho3 , अच्छा खोज!

xgboost:::predict.xgb.Booster() के दस्तावेज़ीकरण पर भी ध्यान दें:

अगर मैं सही ढंग से समझूं, तो दस्तावेज़ीकरण पूरी तरह से सही नहीं है? दस्तावेज़ीकरण के आधार पर, मैं उम्मीद कर रहा था कि भविष्यवाणी पहले से ही सभी पेड़ों का उपयोग कर रही है। दुर्भाग्य से मैंने इसे सत्यापित नहीं किया था।

@DavorJ जब अर्ली स्टॉपिंग सक्रिय होती है, तो predict() भविष्यवाणी प्राप्त करने के लिए best_iteration फ़ील्ड का उपयोग करेगा।

पायथन पक्ष पर @ ट्रिवियलफिस की स्थिति बदतर है, क्योंकि xgb.predict() जल्दी रुकने से जानकारी का उपयोग नहीं करेगा:

import xgboost as xgb
import numpy as np
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split

X, y = load_boston(return_X_y=True)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)

params = {'objective': 'reg:squarederror'}

bst = xgb.train(params, dtrain, 100, [(dtrain, 'train'), (dtest, 'test')],
                early_stopping_rounds=5)

x = bst.predict(dtrain, pred_leaf=True)
x2 = bst.predict(dtrain, pred_leaf=True, ntree_limit=bst.best_iteration)
print(x.shape)
print(x2.shape)

pred = bst.predict(dtrain)
pred2 = bst.predict(dtrain, ntree_limit=bst.best_iteration)

print(np.max(np.abs(pred - pred2)))

आउटपुट:

Will train until test-rmse hasn't improved in 5 rounds.
[1]     train-rmse:12.50316     test-rmse:11.92709
...
[25]    train-rmse:0.56720      test-rmse:2.56874
[26]    train-rmse:0.54151      test-rmse:2.56722
[27]    train-rmse:0.51842      test-rmse:2.56124
[28]    train-rmse:0.47489      test-rmse:2.56640
[29]    train-rmse:0.45489      test-rmse:2.58780
[30]    train-rmse:0.43093      test-rmse:2.59385
[31]    train-rmse:0.41865      test-rmse:2.59364
[32]    train-rmse:0.40823      test-rmse:2.59465
Stopping. Best iteration:
[27]    train-rmse:0.51842      test-rmse:2.56124
(404, 33)
(404, 27)
0.81269073

उपयोगकर्ताओं को लाने की याद करना होगा bst.best_iteration और के रूप में इसे पारित ntree_limit जब बुला तर्क predict() । यह त्रुटि-प्रवण है और एक अप्रिय आश्चर्य बनाता है।

फिक्स के लिए हमारे पास दो विकल्प हैं:

1. best_iteration पहले के पेड़ों को भौतिक रूप से हटा दें।
2. मॉडल को क्रमबद्ध करते समय best_iteration जानकारी बनाए रखें, और predict() फ़ंक्शन का उपयोग करें।

@ hcho3 मेरे पास इसके बारे में एक आधा बेक किया हुआ विचार है, जो हमारे process_type = update विकल्प, और वन से भी संबंधित है।

पृष्ठभूमि

update साथ हमारे पास मौजूद मुद्दों के संक्षिप्त पुनर्कथन के लिए, यदि num_boost_round साथ update का उपयोग पहले से मौजूद पेड़ों की संख्या से कम है, तो वे पेड़ जो अपडेट नहीं किए गए हैं उन्हें हटा दिया जाएगा .

फ़ॉरेस्ट के साथ समस्याओं के संक्षिप्त परिचय के लिए, best_iteration फ़ॉरेस्ट पर लागू नहीं होता है क्योंकि predict फ़ंक्शन को पुनरावृति के बजाय विशिष्ट संख्या में पेड़ों की आवश्यकता होती है, इसलिए पायथन पर best_ntree_limit नामक कुछ है , जो मेरे लिए बहुत भ्रमित करने वाला है। इस विशेषता से बचने के लिए मैंने स्पष्ट रूप से ntree_limit को inplace_predict में iteration_range से बदल दिया।

विचार

मैं slice और concat विधि को booster जोड़ना चाहता हूं, जो पेड़ों को 2 मॉडलों में निकालता है और 2 मॉडलों से पेड़ों को 1 में जोड़ता है। अगर हमारे पास ये 2 विधियां हैं :

• base_margin_ की अब आवश्यकता नहीं है और मेरा मानना ​​है कि यह अन्य उपयोगकर्ताओं के लिए अधिक सहज है।
• भविष्यवाणी में ntree_limit अब आवश्यकता नहीं है, हम केवल मॉडल को स्लाइस करते हैं और स्लाइस पर भविष्यवाणी चलाते हैं।
• update प्रक्रिया स्वयं निहित है, बस एक बार में पेड़ों को स्लाइस में अपडेट करें, num_boost_rounds ।

आगे

इसके अलावा, मेरा मानना ​​​​है कि यह किसी तरह बहु लक्ष्य पेड़ों से जुड़ा है। जैसे कि हम भविष्य में मल्टी-क्लास मल्टी-टारगेट ट्री का समर्थन कर सकते हैं, पेड़ों को व्यवस्थित करने के कई तरीके होंगे, जैसे प्रत्येक क्लास के लिए output_groups का उपयोग करना, या प्रत्येक लक्ष्य, फॉरेस्ट और वेक्टर लीफ के साथ पेयर करना। ntree_limit पर्याप्त नहीं होगा।

साथ ही #5531.

लेकिन विचार बहुत जल्दी है इसलिए मुझे इसे साझा करने का विश्वास नहीं था, अब हम इस मुद्दे पर हैं, शायद मुझे इसके बारे में कुछ जानकारी मिल सकती है।

1.1 समयरेखा को देखते हुए, क्या हम यह स्पष्ट करने के लिए दस्तावेज़ीकरण का विस्तार कर सकते हैं कि उपयोगकर्ताओं को भविष्यवाणी में इस सर्वोत्तम पुनरावृत्ति को मैन्युअल रूप से कैप्चर करने और उपयोग करने की आवश्यकता कैसे है?
और इसे जारी नोटों में ज्ञात मुद्दों में जोड़ें?

@ ट्रिवियलफिस दिलचस्प लगता है, जब तक हम ऐसा करके कॉन्फ़िगरेशन समस्याओं को और जटिल नहीं कर रहे हैं।

@ hcho3 द्वारा सुझाए गए मॉडल से अतिरिक्त पेड़ों को हटाना आकर्षक है क्योंकि हमें एक ही समय में वास्तविक मॉडल लंबाई और सैद्धांतिक मॉडल लंबाई होने से किसी भी विसंगतियों से निपटने की आवश्यकता नहीं है।