दिलचस्प पोस्ट
रेगेक्स को गठजोड़ करें दूसरे के अंदर एक छवि कैसे प्राप्त करें? सी में फ़ंक्शन पॉइंटर के रिकर्सिव घोषणा एंड्रॉइड एक्शन बार में स्विच कैसे जोड़ें? प्रोजेक्ट प्रोटोटाइप पैटर्न में विरासत को लागू करने के लिए कैसे? स्काला 2.8 ब्रेकऑट मैं गैर-समर्थित Jekyll साइट प्लगइन्स का उपयोग करने के लिए GitHub कैसे कॉन्फ़िगर करूं? मैवेन के लिए एक नया पैकेजिंग प्रकार कैसे बनाऊँ? सी # में आरटीएफ में एक स्ट्रिंग कन्वर्ट करने के लिए कैसे? ggplot2: facet_wrap पट्टी रंग डेटा सेट में वेरिएबल के आधार पर इस प्रमाण पत्र में एक अमान्य जारीकर्ता है: चाबी का निशान सभी प्रमाणपत्रों को "अमान्य जारीकर्ता" के रूप में चिह्नित करता है एक नकारात्मक संख्या की तुलना करते समय यह आकार ऑपरेटर के साथ क्यों हो रहा है? जानकारी के लिए एक वेबसाइट (या पेज) को कैसे स्कैन करें, और इसे मेरे कार्यक्रम में लाएं? MSI vs nuget संकुल: कौन सी लगातार डिलीवरी के लिए बेहतर है? रूबी में सरणी टुकड़ा करना: अयोग्य व्यवहार के लिए स्पष्टीकरण (Rubykoans.com से लिया गया)

आर में कैशिंग / मेमोआइज़ेशन / हैशिंग के लिए विकल्प

मैं आर (असल में कैशिंग) में पर्ल के हैश फ़ंक्शन की तरह कुछ का उपयोग करने का एक आसान तरीका ढूँढ़ने की कोशिश कर रहा हूं, क्योंकि मैं पर्ल-स्टाइल हैशिंग दोनों करना चाहता था और गणनाओं की अपनी याददाश्त लिखना चाहता था। हालांकि, अन्य ने मुझे पंच पर मार दिया है और मेमोजिएशन के लिए पैकेज हैं I जितना अधिक मैंने खोदा, उतना अधिक मुझे मिल जाए, जैसे memoise और R.cache , लेकिन अंतर स्पष्ट रूप से स्पष्ट नहीं हैं। इसके अलावा, यह स्पष्ट नहीं है कि कोई भी पर्ल-स्टाइल हैश (या पायथन-स्टाइल डिक्शनरी) को कैसे प्राप्त कर सकता है और hash पैकेज का इस्तेमाल करने के अलावा किसी के स्वयं के मेमोअनाइजेशन को लिख सकता है, जो दो मेमोअनाइजेशन पैकेजों को दबा नहीं करता है।

चूंकि मुझे विकल्प के बीच अंतर करने के लिए सीआरएएन या अन्यत्र कोई जानकारी नहीं मिलती है, शायद यह एक सामुदायिक विकी प्रश्न होना चाहिए ताकि: आर में मेमोआइज़ेशन और कैशिंग के लिए विकल्प क्या हैं, और उनके अंतर क्या हैं?


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

ऐसा लगता है कि विकल्प हैं:

hashing

  • डाइजेस्ट – मनमानी आर ऑब्जेक्ट्स के लिए हैशिंग प्रदान करता है

Memoization

  • मेमोइज़ – फ़ंक्शन के मेमोअनाइजिंग के लिए एक बहुत सरल टूल।
  • R.cache – मेमोअनाइजेशन के लिए और अधिक कार्यक्षमता प्रदान करता है, हालांकि ऐसा लगता है कि कार्यों में से कुछ की कमी के उदाहरण हैं

कैशिंग

  • हैश – पर्ल के हैश और पायथन शब्दकोशों के साथ कैशिंग कार्यक्षमता प्रदान करता है

कुंजी / मूल्य भंडारण

आर वस्तुओं के बाहरी भंडारण के लिए ये बुनियादी विकल्प हैं I

  • stashr
  • filehash

checkpointing

  • केचर – यह चेकपॉइंटिंग के समान अधिक है ।
  • कोडडिपेंड – एक ओमेगाहैट प्रोजेक्ट जो कि cacher आगे cacher और कुछ उपयोगी कार्यक्षमता प्रदान करता है।
  • डीएमटीसीपी (एक आर पैकेज नहीं) – भाषाओं की एक गुच्छा में चेकपॉइंटिंग का समर्थन करने के लिए प्रतीत होता है, और एक डेवलपर ने हाल ही में आर में डीएमटीसीपी चेकपॉइंटिंग सहायता सहायता मांगी थी ।

अन्य

  • बेस आर का समर्थन करता है: नामित वैक्टर और डेटा फ़्रेमों की सूची, पंक्ति और स्तंभ नाम, और वातावरण में वस्तुओं के नाम। मुझे ऐसा लगता है कि सूची का उपयोग करना एक कुंवारा का एक सा है (वहाँ भी pairlist , लेकिन यह नापसंद है ।)
  • डेटाटाइबल पैकेज डेटा तालिका में तत्वों के त्वरित लुकअप का समर्थन करता है।

उदाहरण

यद्यपि मुझे ज्यादातर विकल्प जानने में दिलचस्पी है, लेकिन मेरे पास दो बुनियादी उपयोग के मामले हैं जो उत्पन्न होते हैं:

  1. कैशिंग: तार की सरल गणना [नोट: यह एनएलपी के लिए नहीं है, लेकिन सामान्य उपयोग, इसलिए एनएलपी पुस्तकालय ओवरकिल हैं; तालिकाओं को अपर्याप्त है क्योंकि मैं इंतजार करना पसंद नहीं करता जब तक कि पूरे सेट्स को स्मृति में लोड नहीं किया जाता। पर्ल-स्टाइल हैश उपयोगिता के सही स्तर पर हैं।]
  2. राक्षसी गणना की याद रखना।

ये सचमुच उत्पन्न होते हैं क्योंकि मैं कुछ स्लुबू कोड की रूपरेखा में खुदाई कर रहा हूं और मुझे वास्तव में सरल तार की गणना करना चाहिए और देखें कि क्या मैं मेमोअनाइजेशन के माध्यम से कुछ गणना कर सकता हूं। इनपुट मूल्यों को हैश करने में सक्षम होने के बावजूद, अगर मैं याद नहीं रखता, तो मुझे यह बताना होगा कि मेमोआइजेशन मदद कर सकता है।


नोट 1: पुनरुत्पादक शोध पर क्रान कार्य व्यू कुछ संकुल ( cacher और R.cache ) को R.cache , लेकिन उपयोग के विकल्पों पर कोई विस्तार नहीं होता है

नोट 2: संबंधित कोड की तलाश में दूसरों की सहायता करने के लिए, यहां कुछ लेखकों या पैकेजों पर कुछ नोट्स दिए गए हैं। कुछ लेखकों का उपयोग SO 🙂

  • डीर्क एडलबुएटलः digest – बहुत सारे अन्य संकुल इस पर निर्भर हैं।
  • रोजर पेंग: cacher , filehash , stashR – ये अलग-अलग तरीकों से अलग-अलग समस्याएं हैं; अधिक संकुल के लिए रोजर की साइट देखें
  • क्रिस्टोफर ब्राउन: hash – एक उपयोगी पैकेज लगता है, लेकिन ओडीजी के लिंक नीचे हैं, दुर्भाग्य से।
  • हेनरिक R.cache : R.cache और हैडली विकिम: memoise – यह अभी तक स्पष्ट नहीं हुआ है कि जब दूसरे पर एक पैकेज को पसंद किया जाए

नोट 3: कुछ लोग मेमोइज़ / मेमोइज़ेशन का उपयोग दूसरों को मेमोआइज़ / मेमोअनाइजेशन का उपयोग करते हैं। सिर्फ एक नोट अगर आप चारों ओर खोज रहे हैं हेनरिक "जेड" का उपयोग करता है और हैडली "एस" का उपयोग करता है

वेब के समाधान से एकत्रित समाधान "आर में कैशिंग / मेमोआइज़ेशन / हैशिंग के लिए विकल्प"

तारों की सरल गणना (और table या समान का उपयोग न करने के table ) के लिए, एक मल्टीसेट डेटा संरचना एक अच्छी फिट की तरह दिखती है। environment वस्तु का उपयोग इस अनुकरण के लिए किया जा सकता है।

 # Define the insert function for a multiset msetInsert <- function(mset, s) { if (exists(s, mset, inherits=FALSE)) { mset[[s]] <- mset[[s]] + 1L } else { mset[[s]] <- 1L } } # First we generate a bunch of strings n <- 1e5L # Total number of strings nus <- 1e3L # Number of unique strings ustrs <- paste("Str", seq_len(nus)) set.seed(42) strs <- sample(ustrs, n, replace=TRUE) # Now we use an environment as our multiset mset <- new.env(TRUE, emptyenv()) # Ensure hashing is enabled # ...and insert the strings one by one... for (s in strs) { msetInsert(mset, s) } # Now we should have nus unique strings in the multiset identical(nus, length(mset)) # And the names should be correct identical(sort(ustrs), sort(names(as.list(mset)))) # ...And an example of getting the count for a specific string mset[["Str 3"]] # "Str 3" instance count (97) 

मेरे पास memoise साथ किस्मत नहीं थी क्योंकि memoise उन memoise के कुछ फ़ंक्शन को too deep recursive समस्या दी थी जो मैंने कोशिश की थी। R.cache साथ मुझे बेहतर भाग्य मिला। R.cache दस्तावेज़ीकरण से अनुकूलित अधिक एनोटेट कोड मैं निम्नलिखित है I कोड कैशिंग करने के लिए विभिन्न विकल्पों को दिखाता है।

 # Workaround to avoid question when loading R.cache library dir.create(path="~/.Rcache", showWarnings=F) library("R.cache") setCacheRootPath(path="./.Rcache") # Create .Rcache at current working dir # In case we need the cache path, but not used in this example. cache.root = getCacheRootPath() simulate <- function(mean, sd) { # 1. Try to load cached data, if already generated key <- list(mean, sd) data <- loadCache(key) if (!is.null(data)) { cat("Loaded cached data\n") return(data); } # 2. If not available, generate it. cat("Generating data from scratch...") data <- rnorm(1000, mean=mean, sd=sd) Sys.sleep(1) # Emulate slow algorithm cat("ok\n") saveCache(data, key=key, comment="simulate()") data; } data <- simulate(2.3, 3.0) data <- simulate(2.3, 3.5) a = 2.3 b = 3.0 data <- simulate(a, b) # Will load cached data, params are checked by value # Clean up file.remove(findCache(key=list(2.3,3.0))) file.remove(findCache(key=list(2.3,3.5))) simulate2 <- function(mean, sd) { data <- rnorm(1000, mean=mean, sd=sd) Sys.sleep(1) # Emulate slow algorithm cat("Done generating data from scratch\n") data; } # Easy step to memoize a function # aslo possible to resassign function name. This would work with any functions from external packages. mzs <- addMemoization(simulate2) data <- mzs(2.3, 3.0) data <- mzs(2.3, 3.5) data <- mzs(2.3, 3.0) # Will load cached data # aslo possible to resassign function name. # but different memoizations of the same # function will return the same cache result # if input params are the same simulate2 <- addMemoization(simulate2) data <- simulate2(2.3, 3.0) # If the expression being evaluated depends on # "input" objects, then these must be be specified # explicitly as "key" objects. for (ii in 1:2) { for (kk in 1:3) { cat(sprintf("Iteration #%d:\n", kk)) res <- evalWithMemoization({ cat("Evaluating expression...") a <- kk Sys.sleep(1) cat("done\n") a }, key=list(kk=kk)) # expressions inside 'res' are skipped on the repeated run print(res) # Sanity checks stopifnot(a == kk) # Clean up rm(a) } # for (kk ...) } # for (ii ...) 

@ बोकोसीपार्मन समाधान से संबंधित कैश के लोडिंग, सेविंग और मूल्यांकन से बचने के लिए आरकैचे का रैपिंग फ़ंक्शन है। संशोधित फ़ंक्शन देखें:

R.cache लोडिंग, मूल्यांकन, बचत करने के लिए एक आवरण प्रदान करता है। आप अपने कोड को इस तरह सरल कर सकते हैं:

 simulate <- function(mean, sd) { key <- list(mean, sd) data <- evalWithMemoization(key = key, expr = { cat("Generating data from scratch...") data <- rnorm(1000, mean=mean, sd=sd) Sys.sleep(1) # Emulate slow algorithm cat("ok\n") data}) }