Options pour la mise en cache / memoization / hachage dans la R

Je suis en train d'essayer de trouver un moyen simple d'utiliser quelque chose comme Perl fonctions de hachage dans R (essentiellement la mise en cache), que j'avais l'intention de faire les deux Perl-style de hachage et d'écrire ma propre memoisation de calculs. Cependant, d'autres ont me battre pour le punch et avons des forfaits pour memoisation. Plus je creuse, plus je trouve, par exemple,memoise et R.cache, mais les différences ne sont pas facilement clair. En outre, il n'est pas clair comment on peut obtenir Perl-style de hachages (ou Python-style dictionnaires) et écrire son propre memoization, autres que l'utilisation de la hash paquet, qui ne semble pas sous-tendent les deux memoization paquets.

Depuis que je peux trouver aucune information sur CRAN ou d'ailleurs de distinguer entre les options, peut-être cela devrait être une communauté wiki question DONC: Quelles sont les options pour memoization et la mise en cache dans R, et quelles sont leurs différences?

Comme base de comparaison, voici une liste des options que j'ai trouvé. Aussi, il me semble que tout dépend de hachage, donc je vais noter le hachage et des options. Clé/valeur de stockage est liée en quelque sorte, mais ouvre une énorme boîte de pandore concernant systèmes DB (par exemple, BerkeleyDB, Redis, MemcacheDB et des dizaines d'autres).

On dirait les options sont les suivantes:

De hachage

  • digest - offre de hachage pour arbitraire des objets R.

Memoization

  • memoise - un outil très simple pour memoization de fonctions.
  • R. cache - offre plus de fonctionnalités pour memoization, mais il semble que certaines des fonctions de l'absence d'exemples.

La mise en cache

  • de hachage - Fournit des fonctionnalités de mise en cache semblable à Perl de hachages et les dictionnaires Python.

Clé/valeur de stockage

Ce sont des options de base pour le stockage externe de R objets.

Checkpoint

Autres

  • De la Base de R prend en charge: nom des vecteurs et des listes, en ligne et en colonne les noms des trames de données, et les noms d'objets dans les environnements. Il me semble que l'utilisation d'une liste est un peu de bidouille. (Il y a aussi pairlist, mais c'est déconseillé.)
  • La les données.table package prend en charge rapide des recherches d'éléments dans un tableau de données.

Cas d'utilisation

Même si je suis surtout intéressé à en connaître les options, j'ai deux types d'utilisation de base qui se posent:

  1. La mise en cache: un Simple comptage des chaînes de caractères. [Note: Ce n'est pas pour la PNL, mais en général les utiliser, de sorte que la PNL bibliothèques sont exagéré; les tables sont insuffisants, car je préfère ne pas attendre jusqu'à ce que l'ensemble des chaînes sont chargés en mémoire. Perl-style hachages sont au bon niveau d'utilité.]
  2. Memoization de monstrueux calculs.

Ces vraiment surviennent parce que je suis à creuser pour le profilage de certains slooooow code et je tiens vraiment à ne compter que de simples chaînes et voir si je peux accélérer certains calculs via memoization. Être en mesure de hachage les valeurs d'entrée, même si je n'ai pas memoize, permettez-moi de voir si memoization peut vous aider.

Note 1: Le CRAN Tâche de Vue sur Reproductible de Recherche listes d'un couple de paquets (cacher et R.cache), mais il n'y a pas d'élaboration sur les options d'utilisation.

Note 2: À l'aide d'autres personnes à la recherche de code, voici quelques notes sur certains des auteurs ou des paquets. Certains auteurs utilisent DONC. 🙂

  • Dirk Eddelbuettel: digest - beaucoup d'autres paquets dépendent de ce.
  • Roger Peng: cacher, filehash, stashR - elles s'adressent à différents problèmes de différentes façons; voir Roger du site pour plus de paquets.
  • Christopher Brown: hash - Semble être un bon paquet, mais les liens vers les ODG sont en baisse, malheureusement.
  • Henrik Bengtsson: R.cache & Hadley Wickham: memoise -- il n'est pas encore clair quand à préférer l'une sur l'autre.

Note 3: Certaines personnes utilisent des memoise/memoisation d'autres utilisent memoize/memoization. Juste une remarque, si vous êtes à la recherche autour de. Henrik utilise des "z" et Hadley utilise des "s".

  • Il serait sans doute bon d'ajouter un vrai cas d'utilisation ou deux de sorte que les méthodes peuvent être comparés...
  • Merci, je vais le faire!
  • Perplexe au sujet de vos commentaires re: les environnements. Si vous créez un nouvel environnement, il sera haché. ?environment par exemple, env.profile(new.env())$size # [1] 29
  • Vous êtes correct. Je ne le mentionne comme une option pour une capacité de hachage.
  • Ce post, par l'auteur de "R en un Mot' comprend des tests de vitesse de plusieurs options différentes pour la recherche d'objets, y compris les mettre dans un milieu (où de recherche utilise haché noms) broadcast.oreilly.com/2010/03/lookup-performance-in-r.html . Ne sais pas si c'est utile pour vous, mais je pensais que je serais le cloue à ce poste pour quelqu'un d'autre qui arrive.
  • cacher n'est plus disponible sur CRAN.

InformationsquelleAutor Iterator | 2011-08-31
  1. 9

    Pour un simple comptage de chaînes de caractères (et non pas à l'aide de table ou similaire), un multiset structure de données semble être un bon ajustement. Le environment objet peut être utilisé pour émuler cette.

    # 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)
    InformationsquelleAutor Tommy
  2. 9

    Je n'ai pas eu de chance avec memoise parce qu'il a donné too deep recursive problème à une fonction d'un emballé, j'ai essayé avec. Avec R.cache j'ai eu plus de chance. La suite est plus commenté code que j'ai adapté de R.cache de la documentation. Le code affiche les différentes options pour faire de la mise en cache.

    # 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 ...)
    • Génial! merci!
    InformationsquelleAutor biocyberman
  3. 1

    Liées à @biocyperman solution. R. cache a un emballage de fonction pour éviter le chargement, la sauvegarde et l'évaluation de la cache. Voir la modification de la fonction:

    R. cache fournir un wrapper pour le chargement, l'évaluation, l'enregistrement. Vous pouvez simplifier votre code comme ça:

    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})
}
    InformationsquelleAutor user890739