आर स्मृति प्रबंधन सलाह (कैरट, मॉडल मेट्रिसेस, डेटा फ्रेम)

Question

मैं एक मशीन सीखने के संदर्भ में एक काफी छोटे डाटासेट के साथ काम कर एक सामान्य 8GB सर्वर पर स्मृति से बाहर चल रहा हूँ:

 
> dim(basetrainf) # this is a dataframe 
[1] 58168 118 

केवल पूर्व -मोडलिंग चरण जो मैं लेता हूं जो स्मृति खपत में काफी वृद्धि करता है, डेटा फ्रेम को मॉडल मैट्रिक्स में परिवर्तित करता है। यह caret, cor, आदि के बाद से केवल (मॉडल) matrices के साथ काम करते हैं। कई स्तरों के साथ कारकों को हटाने के बाद भी, मैट्रिक्स (mergem नीचे) काफी बड़ा है। (sparse.model.matrix/Matrix खराब सामान्य रूप में समर्थित है, इसलिए मुझे लगता है कि उपयोग नहीं कर सकते।)

 
> lsos() 
       Type  Size PrettySize Rows Columns 
mergem   matrix 879205616 838.5 Mb 115562  943 
trainf  data.frame 80613120 76.9 Mb 106944  119 
inttrainf  matrix 76642176 73.1 Mb 907 10387 
mergef  data.frame 58264784 55.6 Mb 115562  75 
dfbase  data.frame 48031936 45.8 Mb 54555  115 
basetrainf data.frame 40369328 38.5 Mb 58168  118 
df2  data.frame 34276128 32.7 Mb 54555  103 
tf   data.frame 33182272 31.6 Mb 54555  98 
m.gbm   train 20417696 19.5 Mb  16  NA 
res.glmnet  list 14263256 13.6 Mb  4  NA 

इसके अलावा, कई आर मॉडल के बाद से उदाहरण वजन का समर्थन नहीं करते, मैं पहली बार अल्पसंख्यक वर्ग oversample था, दोहरीकरण मेरे डेटासेट का आकार (क्यों ट्रेनफ, मर्ज, मैर्गम में बेसेट्रेनफ के रूप में कई पंक्तियां हैं)।

आर इस बिंदु पर 1.7 जीबी मेमोरी का उपयोग कर रहा है, जिससे मेरा कुल मेमोरी उपयोग 7.7 जीबी से 4.3 जीबी तक पहुंच गया।

अगली बात मुझे क्या करना है:

 
> m = train(mergem[mergef$istrain,], mergef[mergef$istrain,response], method='rf') 

बैम - कुछ ही सेकंड में, लिनक्स आउट-ऑफ-स्मृति हत्यारा rsession को मारता है।

मैं अपने डेटा का नमूना कर सकता हूं, oversample के बजाय अंडरस्प्ले, आदि, लेकिन ये गैर-आदर्श हैं। मुझे (अन्यथा) क्या करना चाहिए (अलग-अलग), पुनर्लेखन कैरेट और विभिन्न मॉडल पैकेजों का उपयोग करना जो मैं उपयोग करना चाहता हूं?

एफडब्ल्यूआईडब्ल्यू, मैंने कभी भी अन्य एमएल सॉफ़्टवेयर (वेका, ऑरेंज इत्यादि) के साथ इस समस्या में कभी भी भाग नहीं लिया है, यहां तक ​​कि मेरे किसी भी कारक को छेड़छाड़ किए बिना, शायद उदाहरण भार और "डेटा फ्रेम" समर्थन दोनों के कारण सभी मॉडल।

पूरा स्क्रिप्ट इस प्रकार है:

 
library(caret) 
library(Matrix) 
library(doMC) 
registerDoMC(2) 

response = 'class' 

repr = 'dummy' 
do.impute = F 

xmode = function(xs) names(which.max(table(xs))) 

read.orng = function(path) { 
    # read header 
    hdr = strsplit(readLines(path, n=1), '\t') 
    pairs = sapply(hdr, function(field) strsplit(field, '#')) 
    names = sapply(pairs, function(pair) pair[2]) 
    classes = sapply(pairs, function(pair) 
    if (grepl('C', pair[1])) 'numeric' else 'factor') 

    # read data 
    dfbase = read.table(path, header=T, sep='\t', quote='', col.names=names, na.strings='?', colClasses=classes, comment.char='') 

    # switch response, remove meta columns 
    df = dfbase[sapply(pairs, function(pair) !grepl('m', pair[1]) && pair[2] != 'class' || pair[2] == response)] 

    df 
} 

train.and.test = function(x, y, trains, method) { 
    m = train(x[trains,], y[trains,], method=method) 
    ps = extractPrediction(list(m), testX=x[!trains,], testY=y[!trains,]) 
    perf = postResample(ps$pred, ps$obs) 
    list(m=m, ps=ps, perf=perf) 
} 

# From 
sparse.cor = function(x){ 
    memory.limit(size=10000) 
    n 200 levels') 
badfactors = sapply(mergef, function(x) 
    is.factor(x) && (nlevels(x) 200)) 
mergef = mergef[, -which(badfactors)] 

print('remove near-zero variance predictors') 
mergef = mergef[, -nearZeroVar(mergef)] 

print('create model matrix, making everything numeric') 
if (repr == 'dummy') { 
    dummies = dummyVars(as.formula(paste(response, '~ .')), mergef) 
    mergem = predict(dummies, newdata=mergef) 
} else { 
    mat = if (repr == 'sparse') model.matrix else sparse.model.matrix 
    mergem = mat(as.formula(paste(response, '~ .')), data=mergef) 
    # remove intercept column 
    mergem = mergem[, -1] 
} 

print('remove high-correlation predictors') 
merge.cor = (if (repr == 'sparse') sparse.cor else cor)(mergem) 
mergem = mergem[, -findCorrelation(merge.cor, cutoff=.75)] 

print('try a couple of different methods') 
do.method = function(method) { 
    train.and.test(mergem, mergef[response], mergef$istrain, method) 
} 
res.gbm = do.method('gbm') 
res.glmnet = do.method('glmnet') 
res.rf = do.method('parRF') 

Answer 1

जांचें कि अंतर्निहित randomForest कोड पेड़ों के जंगल को संग्रहीत नहीं कर रहा है। शायद tuneLength को कम करें ताकि mtry के कम मूल्यों की कोशिश की जा रही है।

इसके अलावा, मैं शायद यह देखने के लिए कि मैं अपनी मशीन पर ऐसे मॉडल को फिट कर सकता हूं, मैं शायद एक ही यादृच्छिक वन फिट करूँगा। यदि आप सीधे एक फिट नहीं कर सकते हैं, तो आप एक बार में कई फिट करने के लिए देखभाल का उपयोग करने में सक्षम नहीं होंगे।

इस बिंदु पर मुझे लगता है कि आपको काम करने की ज़रूरत है कि स्मृति को गुब्बारा क्या हो रहा है और आप मॉडल फिटिंग को कैसे नियंत्रित कर सकते हैं ताकि यह नियंत्रण से बाहर न हो। तो कैसे काम करें देखभालrandomForest() पर कॉल कर रहा है और इसका उपयोग किस विकल्प का उपयोग कर रहा है। आप उनमें से कुछ को बंद करने में सक्षम हो सकते हैं (जैसे जंगल को संग्रहीत करना, जैसा कि मैंने पहले उल्लेख किया था, लेकिन चरम महत्व उपायों)। एक बार जब आप mtry के लिए इष्टतम मान निर्धारित कर लेंगे, तो आप फिट को समझने में सहायता करने के लिए सभी अतिरिक्त सुविधाओं के साथ मॉडल को फिट करने का प्रयास कर सकते हैं।

Answer 2

आप एफएफ पैकेज है, जो "डिस्क और तेजी से पहुँच कार्यों पर बड़ा डेटा की स्मृति कुशल भंडारण" लागू करता है इस्तेमाल करने की कोशिश कर सकते हैं।

Answer 3

उस डेटा के साथ, पुन: संकलित त्रुटि अनुमान और यादृच्छिक वन ओओबी त्रुटि अनुमान बहुत करीब होना चाहिए।trainControl(method = "OOB") और train() का उपयोग करने का प्रयास करें resampled डेटा सेट पर अतिरिक्त मॉडल फिट नहीं होगा।

इसके अलावा, प्लेग जैसे सूत्र इंटरफ़ेस से बचें।

आप इसके बजाय बैगिंग करने का प्रयास भी कर सकते हैं। चूंकि प्रत्येक थूक पर भविष्यवाणियों का कोई यादृच्छिक चयन नहीं होता है, इसलिए आप 50-100 resamples के साथ अच्छा परिणाम प्राप्त कर सकते हैं (यादृच्छिक जंगलों द्वारा कई और आवश्यक होने के बजाय)।

अन्य असहमत हो सकते हैं, लेकिन मुझे यह भी लगता है कि आपके पास मौजूद सभी डेटा मॉडलिंग हमेशा सर्वोत्तम दृष्टिकोण नहीं है। जब तक भविष्यवाणियों की जगह बड़ी न हो, तब तक कई डेटा पॉइंट दूसरों के समान ही होंगे और मॉडल फिट में अतिरिक्त योगदान नहीं देंगे (अतिरिक्त गणना गणना और परिणामी वस्तु के पदचिह्न के अलावा)। caret में maxDissim नामक एक फ़ंक्शन है जो डेटा को पतला करने में सहायक हो सकता है (हालांकि यह बहुत कुशल नहीं है)