आर

Question

में बहुत बड़े डेटा सेटों की प्लॉटिंग मैं आर में एक बहुत बड़ा डेटा सेट कैसे प्लॉट कर सकता हूं?

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

Answer 1

पूरक में मेरी टिप्पणी करने के लिए Dmitri answer को एक समारोह ff बड़े डेटा से निपटने के पैकेज का उपयोग quantiles गणना करने के लिए:

ffquantile<-function(ffv,qs=c(0,0.25,0.5,0.75,1),...){ 
stopifnot(all(qs<=1 & qs>=0)) 
ffsort(ffv,...)->ffvs 
j<-(qs*(length(ffv)-1))+1 
jf<-floor(j);ceiling(j)->jc 
rowSums(matrix(ffvs[c(jf,jc)],length(qs),2))/2 
} 

यह एक सटीक एल्गोरिथ्म है, इसलिए यह छँटाई का उपयोग करता है - और इस तरह हो सकता है बहुत समय लीजिये।

Answer 2

आपको बॉक्सप्लॉट की आवश्यकता है क्वांटाइल, "व्हिस्कर" चरम सीमाएं, और आउटलायर (यदि दिखाया गया है), जो कि आसानी से प्रीकंप्यूटेड है। boxplot.stats फ़ंक्शन पर एक नज़र डालें।

Answer 3

आप अपने डेटा के प्रबंधनीय नमूने से भूखंड बना सकते हैं। जैसे यदि आप केवल 10% यादृच्छिक रूप से चुनी गई पंक्तियों का उपयोग करते हैं तो इस नमूने पर बॉक्सप्लॉट सभी डेटा बॉक्सप्लॉट से अलग नहीं होना चाहिए।

यदि आपका डेटा कुछ डेटाबेस पर है तो आप कुछ यादृच्छिक ध्वज बनाने में सक्षम होंगे (जैसा कि मुझे पता है कि लगभग हर डेटाबेस इंजन में किसी प्रकार का यादृच्छिक संख्या जनरेटर होता है)।

दूसरी बात यह है कि आपका डेटासेट कितना बड़ा है? बॉक्सप्लॉट के लिए आपको दो कॉलम चाहिए: वैल्यू वेरिएबल और ग्रुप वेरिएबल। यह उदाहरण:

N <- 1e6 
x <- rnorm(N) 
b <- sapply(1:100, function(i) paste(sample(letters,40,TRUE),collapse="")) 
g <- factor(sample(b,N,TRUE)) 
boxplot(x~g) 

100MB रैम की आवश्यकता है। यदि N=1e7 तो यह < 1 जीबी रैम का उपयोग करता है (जो अभी भी आधुनिक मशीन के लिए प्रबंधनीय है)।

Answer 4

यह एक दिलचस्प समस्या है।

बॉक्सप्लॉट्स को क्वांटाइल की आवश्यकता होती है। बहुत बड़े डेटासेट पर कंप्यूटिंग क्वांटाइल मुश्किल है।

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

वैकल्पिक रूप से, ऐसे एल्गोरिदम मौजूद हैं जो आर्थिक रूप से और लगभग "ऑनलाइन" फैशन में क्वांटाइल की गणना कर सकते हैं, जिसका अर्थ है कि उन्हें एक समय में एक अवलोकन के साथ प्रस्तुत किया जाता है, और प्रत्येक अवलोकन बिल्कुल एक बार दिखाया जाता है। जबकि मेरे पास ऐसे एल्गोरिदम के साथ कुछ सीमित अनुभव है, मैंने किसी भी आसानी से उपलब्ध आर कार्यान्वयन को नहीं देखा है।

निम्नलिखित पेपर कुछ प्रासंगिक एल्गोरिदम का एक संक्षिप्त अवलोकन प्रस्तुत करता है: Quantiles on Streams।

Answer 5

समस्या यह है कि आप स्मृति में सभी डेटा लोड नहीं कर सकते हैं। तो आप डेटा का नमूनाकरण कर सकते हैं, जैसा कि पहले @Marek द्वारा दर्शाया गया था। इस तरह के एक विशाल डेटासेट पर, आप अनिवार्य रूप से वही परिणाम प्राप्त करते हैं भले ही आप डेटा का केवल 1% लेते हैं। वायलिन साजिश के लिए, यह आपको घनत्व का एक सभ्य अनुमान देगा। क्वांटाइल की प्रगतिशील गणना असंभव है, लेकिन यह एक बहुत सभ्य अनुमान देना चाहिए। यह अनिवार्य रूप से लिंक @aix में वर्णित "यादृच्छिक विधि" जैसा ही है।

यदि आप आर के बाहर की तारीख को सब्सक्राइब नहीं कर सकते हैं, तो इसे sample() के साथ संयोजन में कनेक्शन का उपयोग करके किया जा सकता है। निम्नलिखित फ़ंक्शन वह है जो मैं टेक्स्ट प्रारूप में डेटाफ्रेम से नमूना डेटा का उपयोग करता हूं, जब यह बहुत बड़ा हो रहा है। यदि आप कनेक्शन के साथ थोड़ा सा खेलते हैं, तो आप आसानी से इसे किसी सॉकेट कनेक्शन में परिवर्तित कर सकते हैं या अन्य इसे सर्वर, डेटाबेस, जो कुछ भी पढ़ सकते हैं। बस सुनिश्चित करें कि आप सही मोड में कनेक्शन खोलें।

अच्छा, सरल लें।csv फ़ाइल, तो समारोह के नमूने डेटा का एक अंश पी निम्नलिखित:

sample.df <- function(f,n=10000,split=",",p=0.1){ 
    con <- file(f,open="rt",) 
    on.exit(close(con,type="rt")) 
    y <- data.frame() 
    #read header 
    x <- character(0) 
    while(length(x)==0){ 
     x <- strsplit(readLines(con,n=1),split)[[1]] 
    } 
    Names <- x 
    #read and process data 
    repeat{ 
     x <- tryCatch(read.table(con,nrows=n,sep=split),error = function(e) NULL) 
     if(is.null(x)) {break} 
     names(x) <- Names 
     nn <- nrow(x) 
     id <- sample(1:nn,round(nn*p)) 
     y <- rbind(y,x[id,]) 
    } 
    rownames(y) <- NULL 
    return(y) 
} 

उपयोग का एक उदाहरण:

#Make a file 
Df <- data.frame(
    X1=1:10000, 
    X2=1:10000, 
    X3=rep(letters[1:10],1000) 
) 
write.csv(Df,file="test.txt",row.names=F,quote=F) 

# n is number of lines to be read at once, p is the fraction to sample 
DF2 <- sample.df("test.txt",n=1000,p=0.2) 
str(DF2) 

#clean up 
unlink("test.txt") 

Answer 6

तुम भी RSQLite, SQLiteDF, RODBC, और biglm संकुल पर गौर करना चाहिए। बड़े डेटासेट के लिए डेटाबेस में डेटा को स्टोर करने के लिए उपयोगी हो सकता है और केवल टुकड़ों को आर में खींच सकता है। डेटाबेस आपके लिए सॉर्टिंग भी कर सकते हैं और फिर सॉर्ट किए गए डेटा पर क्वांटाइल कंप्यूटिंग करना बहुत आसान है (फिर प्लॉट करने के लिए क्वांटाइल का उपयोग करें) ।

बहुत बड़े डेटासेट के साथ स्कैटरप्लॉट समकक्ष करने के लिए हेक्सबिन पैकेज (बायोकॉन्डक्टर) भी है (शायद अभी भी डेटा का नमूना उपयोग करना चाहते हैं, लेकिन बड़े नमूने के साथ काम करता है)।

Answer 7

आप डेटा को डेटाबेस में डाल सकते हैं और SQL का उपयोग करके क्वांटाइल की गणना कर सकते हैं। देखें: http://forge.mysql.com/tools/tool.php?id=149