आर जीबीएम लापता मूल्यों का हैंडलिंग

Question

क्या किसी को पता है कि gbmR में गुम मूल्यों को कैसे संभालता है? मुझे Google का उपयोग करके कोई स्पष्टीकरण नहीं मिल रहा है।

Answer 1

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

मान लीजिए कि आपके पास एक gbm ऑब्जेक्ट mygbm है। pretty.gbm.tree(mygbm, i.tree=1) का उपयोग करके आप mygbm पर पहले पेड़, उदा .:

SplitVar SplitCodePred LeftNode RightNode MissingNode ErrorReduction Weight Prediction 
0  46 1.629728e+01  1   5   9  26.462908 1585 -4.396393e-06 
1  45 1.850000e+01  2   3   4  11.363868 939 -4.370936e-04 
2  -1 2.602236e-04  -1  -1   -1  0.000000 271 2.602236e-04 
3  -1 -7.199873e-04  -1  -1   -1  0.000000 668 -7.199873e-04 
4  -1 -4.370936e-04  -1  -1   -1  0.000000 939 -4.370936e-04 
5  20 0.000000e+00  6   7   8  8.638042 646 6.245552e-04 
6  -1 3.533436e-04  -1  -1   -1  0.000000 483 3.533436e-04 
7  -1 1.428207e-03  -1  -1   -1  0.000000 163 1.428207e-03 
8  -1 6.245552e-04  -1  -1   -1  0.000000 646 6.245552e-04 
9  -1 -4.396393e-06  -1  -1   -1  0.000000 1585 -4.396393e-06 

जानकारी के लिए जीबीएम दस्तावेज़ देखें कल्पना कर सकते हैं। प्रत्येक पंक्ति नोड से मेल खाती है, और पहला (अनामित) कॉलम नोड नंबर होता है। हम देखते हैं कि प्रत्येक नोड में बाएं और दाएं नोड होते हैं (जो नोड एक पत्ता होता है) में -1 पर सेट होते हैं। हम यह भी देखते हैं कि प्रत्येक नोड ने MissingNode से जुड़ा हुआ है।

पेड़ के नीचे एक अवलोकन चलाने के लिए, हम नोड 0 पर शुरू होते हैं। यदि अवलोकन में SplitVar = 46 पर गुम मूल्य है, तो इसे पेड़ को नोड MissingNode = 9 पर भेजा जाएगा। पेड़ की भविष्यवाणी इस तरह के अवलोकन के लिए SplitCodePred = -4.396393e-06 होगा, जो एक ही भविष्यवाणी है कि किसी भी विभाजन को नोड शून्य (Prediction = -4.396393e-06 नोड शून्य के लिए) से पहले विभाजित किया गया था।

प्रक्रिया अन्य नोड्स और विभाजित चर के लिए समान है।

Answer 2

तब स्रोत कोड से प्रारंभ करें।

function (formula = formula(data), distribution = "bernoulli", 
    data = list(), weights, var.monotone = NULL, n.trees = 100, 
    interaction.depth = 1, n.minobsinnode = 10, shrinkage = 0.001, 
    bag.fraction = 0.5, train.fraction = 1, cv.folds = 0, keep.data = TRUE, 
    verbose = TRUE) 
{ 
    mf <- match.call(expand.dots = FALSE) 
    m <- match(c("formula", "data", "weights", "offset"), names(mf), 
     0) 
    mf <- mf[c(1, m)] 
    mf$drop.unused.levels <- TRUE 
    mf$na.action <- na.pass 
    mf[[1]] <- as.name("model.frame") 
    mf <- eval(mf, parent.frame()) 
    Terms <- attr(mf, "terms") 
    y <- model.response(mf, "numeric") 
    w <- model.weights(mf) 
    offset <- model.offset(mf) 
    var.names <- attributes(Terms)$term.labels 
    x <- model.frame(terms(reformulate(var.names)), data, na.action = na.pass) 
    response.name <- as.character(formula[[2]]) 
    if (is.character(distribution)) 
     distribution <- list(name = distribution) 
    cv.error <- NULL 
    if (cv.folds > 1) { 
     if (distribution$name == "coxph") 
      i.train <- 1:floor(train.fraction * nrow(y)) 
     else i.train <- 1:floor(train.fraction * length(y)) 
     cv.group <- sample(rep(1:cv.folds, length = length(i.train))) 
     cv.error <- rep(0, n.trees) 
     for (i.cv in 1:cv.folds) { 
      if (verbose) 
       cat("CV:", i.cv, "\n") 
      i <- order(cv.group == i.cv) 
      gbm.obj <- gbm.fit(x[i.train, , drop = FALSE][i, 
       , drop = FALSE], y[i.train][i], offset = offset[i.train][i], 
       distribution = distribution, w = ifelse(w == 
        NULL, NULL, w[i.train][i]), var.monotone = var.monotone, 
       n.trees = n.trees, interaction.depth = interaction.depth, 
       n.minobsinnode = n.minobsinnode, shrinkage = shrinkage, 
       bag.fraction = bag.fraction, train.fraction = mean(cv.group != 
        i.cv), keep.data = FALSE, verbose = verbose, 
       var.names = var.names, response.name = response.name) 
      cv.error <- cv.error + gbm.obj$valid.error * sum(cv.group == 
       i.cv) 
     } 
     cv.error <- cv.error/length(i.train) 
    } 
    gbm.obj <- gbm.fit(x, y, offset = offset, distribution = distribution, 
     w = w, var.monotone = var.monotone, n.trees = n.trees, 
     interaction.depth = interaction.depth, n.minobsinnode = n.minobsinnode, 
     shrinkage = shrinkage, bag.fraction = bag.fraction, train.fraction = train.fraction, 
     keep.data = keep.data, verbose = verbose, var.names = var.names, 
     response.name = response.name) 
    gbm.obj$Terms <- Terms 
    gbm.obj$cv.error <- cv.error 
    gbm.obj$cv.folds <- cv.folds 
    return(gbm.obj) 
} 
<environment: namespace:gbm> 

एक त्वरित पढ़ा पता चलता है कि डेटा एक मॉडल फ्रेम में और कहा कि एनए के na.pass तो बदले में, ?na.pass पढ़ना उस के साथ नियंत्रित किया जाता है डाल दिया जाता है, यह की तरह लग रहा: बस कंसोल पर gbm टाइपिंग आप स्रोत कोड से पता चलता यह उनके साथ कुछ भी खास नहीं करता है, लेकिन आपको लंबे समय तक इसका अर्थ देखने के लिए शायद पूरी फिटिंग प्रक्रिया पर पढ़ना होगा। ऐसा लगता है कि आपको gbm.fit और इसी तरह के कोड को भी देखने की आवश्यकता हो सकती है।

Answer 3

official guide जीबीएमएस के लिए परीक्षण डेटा में अनुपलब्ध मान प्रस्तुत करता है, इसलिए मुझे लगता है कि वे गुम मूल्यों को संभालने के लिए कोड किए गए हैं।

Answer 4

ऐसा लगता है कि प्रत्येक पेड़ के भीतर एक अलग नोड को लापता मान भेजना प्रतीत होता है। यदि आपके पास "mygbm" नामक एक जीबीएम ऑब्जेक्ट है तो आप "pretty.gbm.tree (mygbm, i.tree = 1)" टाइप करके देखेंगे कि पेड़ में प्रत्येक विभाजन के लिए एक बाएं नोड एक राइट नोड और एक मिसिंग नोड है। इसका तात्पर्य है कि (मान लीजिए कि आपके पास इंटरैक्शन है। डीपीएच = 1) प्रत्येक पेड़ में 3 टर्मिनल नोड्स होंगे (विभाजन के प्रत्येक पक्ष के लिए 1 और एक जहां भविष्यवाणीकर्ता गुम है)।

Answer 5

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

यदि आप सरोगेट को बेहतर ढंग से विभाजित करना चाहते हैं, तो मैं package rpart vignette पढ़ने की सलाह देता हूं।