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

Question

क्या load() का उपयोग कर आर में लोड किए गए डेटा के लिए प्रगति पट्टी बनाना संभव है?

डेटा विश्लेषण प्रोजेक्ट के लिए आर में बड़ी मैट्रिस लोड की जा रही हैं। डेटा फ़ाइलों को लोड करने में कई मिनट लगते हैं। मैं यह देखने के लिए एक प्रगति पट्टी रखना चाहता हूं कि डेटा लोड होने से पहले कितना समय लगेगा। आर में पहले से ही progress bar कार्यक्षमता एकीकृत है, लेकिन लोड() के पास यह देखने के लिए कोई हुक नहीं है कि कितना डेटा पढ़ा गया है। अगर मैं सीधे लोड का उपयोग नहीं कर सकता, तो क्या कोई अप्रत्यक्ष तरीका है कि मैं ऐसी प्रगति पट्टी बना सकता हूं? शायद आरएडीएटी फाइल को चक्स में लोड करना और आर के लिए उन्हें एक साथ रखना। क्या किसी के पास इस पर कोई विचार या सुझाव है?

Answer 1

मैं निम्नलिखित समाधान के साथ आया, जो 2^32 - 1 बाइट से कम फ़ाइल आकारों के लिए काम करेगा।

आर ऑब्जेक्ट को क्रमबद्ध करने और फ़ाइल में सहेजी जाने की आवश्यकता है, जैसा कि निम्न कोड द्वारा किया गया है।

saveObj <- function(object, file.name){ 
    outfile <- file(file.name, "wb") 
    serialize(object, outfile) 
    close(outfile) 
} 

फिर हम भाग में द्विआधारी डेटा पढ़ते हैं, इस पर ध्यान रखते हुए कि प्रगति पट्टी को कितना पढ़ा और अपडेट किया जा रहा है।

loadObj <- function(file.name){ 
    library(foreach) 
    filesize <- file.info(file.name)$size 
    chunksize <- ceiling(filesize/100) 
    pb <- txtProgressBar(min = 0, max = 100, style=3) 
    infile <- file(file.name, "rb") 
    data <- foreach(it = icount(100), .combine = c) %do% { 
     setTxtProgressBar(pb, it) 
     readBin(infile, "raw", chunksize) 
    } 
    close(infile) 
    close(pb) 
    return(unserialize(data)) 
} 

कोड इस प्रकार चलाया जा सकता है:

> a <- 1:100000000 
> saveObj(a, "temp.RData") 
> b <- loadObj("temp.RData") 
    |======================================================================| 100% 
> all.equal(b, a) 
[1] TRUE 

अगर हम बेंचमार्क एक भी हिस्सा हम देख प्रगति बार विधि थोड़ी धीमी है में फ़ाइल को पढ़ने के खिलाफ प्रगति बार विधि, लेकिन पर्याप्त नहीं के बारे में चिंता करना।

> system.time(unserialize(readBin(infile, "raw", file.info("temp.RData")$size))) 
    user system elapsed 
    2.710 0.340 3.062 
> system.time(b <- loadObj("temp.RData")) 
    |======================================================================| 100% 
    user system elapsed 
    3.750 0.400 4.154 

इसलिए उपर्युक्त विधि काम करता है, मुझे लगता है कि फ़ाइल आकार प्रतिबंधों के कारण यह पूरी तरह बेकार है। प्रोग्रेस बार केवल उन बड़ी फ़ाइलों के लिए उपयोगी हैं जो पढ़ने में काफी समय लेते हैं।

यह अच्छा होगा अगर कोई इस समाधान से बेहतर कुछ के साथ आ सकता है!

Answer 2

क्या मैं इसके बजाय लोड (और सहेजने) समय को तेज करने का सुझाव देता हूं ताकि प्रगति पट्टी की आवश्यकता न हो? यदि एक मैट्रिक्स पढ़ना "तेज़" है, तो आप संभावित रूप से प्रत्येक पठित मैट्रिक्स (यदि आपके पास बहुत से हैं) के बीच प्रगति की रिपोर्ट कर सकते हैं।

यहां कुछ माप दिए गए हैं। बस संपीड़न = FALSE सेट करके, लोड की गति दोगुना हो जाती है। लेकिन एक साधारण मैट्रिक्स सीरियलाइज़र लिखकर, लोड की गति लगभग 20x तेज है।

x <- matrix(runif(1e7), 1e5) # Matrix with 100k rows and 100 columns 

system.time(save('x', file='c:/foo.bin')) # 13.26 seconds 
system.time(load(file='c:/foo.bin')) # 2.03 seconds 

system.time(save('x', file='c:/foo.bin', compress=FALSE)) # 0.86 seconds 
system.time(load(file='c:/foo.bin')) # 0.92 seconds 

system.time(saveMatrix(x, 'c:/foo.bin')) # 0.70 seconds 
system.time(y <- loadMatrix('c:/foo.bin')) # 0.11 seconds !!! 
identical(x,y) 

जहां saveMatrix/loadMatrix को निम्नानुसार परिभाषित किया गया है। वे वर्तमान में dimnames और अन्य विशेषताओं को संभाल नहीं है, लेकिन यह आसानी से जोड़ा जा सकता है।

saveMatrix <- function(m, fileName) { 
    con <- file(fileName, 'wb') 
    on.exit(close(con)) 
    writeBin(dim(m), con) 
    writeBin(typeof(m), con) 
    writeBin(c(m), con) 
} 

loadMatrix <- function(fileName) { 
    con <- file(fileName, 'rb') 
    on.exit(close(con)) 
    d <- readBin(con, 'integer', 2) 
    type <- readBin(con, 'character', 1) 
    structure(readBin(con, type, prod(d)), dim=d) 
}