आर

2013-02-10 8 views
6

में परिवर्तनीय नामों वाली एक सूची बढ़ाना मैं आर में एक सूची विकसित करने की कोशिश कर रहा हूं, जहां प्रत्येक प्रविष्टि का मूल्य और नाम एक चर में आयोजित होता है, लेकिन ऐसा लगता है कि यह काम नहीं करता है।आर

my_models_names <- names(my_models) 
my_rocs=list() 
for (modl in my_models_names) { 

    my_probs <- testPred[[modl]]$Y1 
    my_roc <- roc(Ytst, my_probs) 
    c(my_rocs, modl=my_roc) # <-- modl and my_roc are both variables 
    } 

मेरी सूची my_rocs अंत में खाली है, भले ही मुझे पता है कि पाश दोहराता (my_roc में भर जाता है) क्यों?

संबंधित नोट पर, क्या लूपिंग के बिना ऐसा करने का कोई तरीका है?

+2

पुन: उत्पादित उदाहरण कृपया ... ?? http://tinyurl.com/reproducible-000 ... 'lapply' समस्या के बिना करने का तरीका है (स्पष्ट) लूपिंग –

+0

धन्यवाद @ बेनबॉल्कर। आप सही हैं, इसे उपलब्ध कराने के लिए क्षमा करें, मैं एक साथ रखूंगा, लेकिन उस समय मुझे लगता है कि मुझे एक और धागे पर एक जवाब मिला है। –

उत्तर

2

मुझे this thread पर उत्तर मिला।

मैं निम्नलिखित सामान्य सूत्र का उपयोग कर एक सूची बढ़ सकता है:

mylist <- list() 

for (key in my_keys){ 
mylist[[ key ]] <- value # value is computed dynamically 
} 

मेरी ओपी में:

  • mylistmy_rocs
  • key है modl
  • value है my_roc
  • है 10
+1

मैं वास्तव में वस्तु को बढ़ाने पर विचार नहीं करता, जब 'mylist' बड़ा हो जाता है तो यह वास्तव में धीमा हो जाता है। 'Lapply' (जो इसे करने का आर-तरीका है) का उपयोग करके उदाहरण के लिए मेरा उत्तर देखें, या अपने' mylist' को सही आकार में प्रीलाकेट करें। जब 'mylist' छोटा होता है तो इससे कोई फर्क नहीं पड़ता है, लेकिन सामान्य रूप से यह शैली धीमी है। –

+0

यदि यह lapply() के साथ प्रति कुंजी एकाधिक सूचियों को क्रॉवेट करने की आवश्यकता है तो यह किया जा सकता है? @PaulHiemstra –

13

आम तौर पर आर में, बढ़ती वस्तुओं खराब है। यह पूर्ण वस्तु से शुरू होने और इसे भरने के लिए उपयोग की जाने वाली स्मृति की मात्रा को बढ़ाता है। ऐसा लगता है कि आपको पता है कि सूची का आकार पहले से ही होना चाहिए।

उदाहरण के लिए:

my_keys <- letters[1:3] 
mylist <- vector(mode="list", length=length(my_keys)) 
names(mylist) <- my_keys 

mylist 
## $a 
## NULL 

## $b 
## NULL 

## $c 
## NULL 

आप काम इस तरह से कर सकते हैं:

key <- "a" 
mylist[[key]] <- 5 
mylist 
## $a 
## [1] 5 
## 
## $b 
## NULL 
## 
## $c 
## NULL 
+0

+1। और अधिक महत्वपूर्ण है कि स्मृति उपयोग, स्मृति की निरंतर पुनर्वितरण बड़े डेटासेट के लिए एक वस्तु को बहुत धीमा कर देता है, जो कि परिमाण के कई आदेशों तक है। –

3

तुम भी एक और अधिक अनुसंधान की तरह soltution उपयोग कर सकते हैं, और प्रयोग lapply:

get_model = function(model_name) { 
    my_probs <- testPred[[model_name]]$Y1 
    return(roc(Ytst, my_probs)) 
    } 
model_list = lapply(names(my_models), get_model) 

ध्यान दें कि यह समाधान आपको बहुत सारे बॉयलरप्लेट कोड बचाता है, यह भी realloc से पीड़ित नहीं है ऑब्जेक्ट को बढ़ाकर आपके समाधान की आयन समस्या। बड़े डेटासेट के लिए, इसका मतलब यह हो सकता है कि lapply समाधान हजारों गुना तेज है।