Existe-t-il une manière normalisée dans R de mesurer le temps d'exécution d'une fonction?
Évidemment, je peux prendre system.time
avant et après l'exécution, puis prendre la différence, mais j'aimerais savoir s'il existe une manière ou une fonction normalisée (ne souhaite pas inventer la roue).
Il me semble me rappeler que j’ai déjà utilisé quelque chose comme ci-dessous:
somesysfunction("myfunction(with,arguments)")
> Start time : 2001-01-01 00:00:00 # output of somesysfunction
> "Result" "of" "myfunction" # output of myfunction
> End time : 2001-01-01 00:00:10 # output of somesysfunction
> Total Execution time : 10 seconds # output of somesysfunction
Une autre façon de faire serait d'utiliser Sys.time ():
start.time <- Sys.time()
...Relevent codes...
end.time <- Sys.time()
time.taken <- end.time - start.time
time.taken
Pas la façon la plus élégante de le faire, comparée à la réponse ci-dessus, mais certainement une façon de le faire.
La fonction intégrée system.time()
le fera.
Utilisez comme: system.time(result <- myfunction(with, arguments))
Comme Andrie l'a dit, system.time()
fonctionne bien. Pour une fonction courte, je préfère y mettre replicate()
:
system.time( replicate(10000, myfunction(with,arguments) ) )
Une façon légèrement plus agréable de mesurer le temps d'exécution consiste à utiliser le package rbenchmark . Ce package (facilement) vous permet de spécifier le nombre de fois où répliquer votre test et quel devrait être le point de repère relatif.
Voir aussi une question connexe à l'adresse stats.stackexchange
Il y a aussi proc.time()
Vous pouvez utiliser de la même manière que Sys.time
mais vous obtenez un résultat similaire à system.time
.
ptm <- proc.time()
#your function here
proc.time() - ptm
la principale différence entre l'utilisation
system.time({ #your function here })
est-ce que la méthode proc.time()
exécute toujours votre fonction au lieu de simplement mesurer le temps ... et d'ailleurs, j'aime bien utiliser system.time
avec {}
à l'intérieur pour vous permettre de définir un ensemble de choses...
Le paquet "tictoc" vous donne un moyen très simple de mesurer le temps d'exécution. La documentation est dans: https://cran.fhcrc.org/web/packages/tictoc/tictoc.pdf .
install.packages("tictoc")
require(tictoc)
tic()
rnorm(1000,0,1)
toc()
Pour enregistrer le temps écoulé dans une variable, vous pouvez effectuer les opérations suivantes:
install.packages("tictoc")
require(tictoc)
tic()
rnorm(1000,0,1)
exectime <- toc()
exectime <- exectime$toc - exectime$tic
microbenchmark
est un package léger (~ 50 Ko) et, plus ou moins, une méthode standard en R permettant de comparer plusieurs expressions et fonctions:
microbenchmark(myfunction(with,arguments))
Par exemple:
> microbenchmark::microbenchmark(log10(5), log(5)/log(10), times = 10000)
Unit: nanoseconds
expr min lq mean median uq max neval cld
log10(5) 0 0 25.5738 0 1 10265 10000 a
log(5)/log(10) 0 0 28.1838 0 1 10265 10000
Ici, les deux expressions ont été évaluées 10000 fois, le temps moyen d'exécution étant d'environ 25-30 ns.
Bien que d'autres solutions soient utiles pour une seule fonction, je recommande le code suivant, qui est plus général et efficace:
Rprof ( tf <- "log.log", memory.profiling = TRUE )
your code must be in between
Rprof ( NULL ) ; print ( summaryRprof ( tf ) )
Vous pouvez utiliser les fonctions tic
-toc
de MATLAB, si vous préférez. Voir cette autre SO question
Un autre moyen simple mais très puissant de faire cela consiste à utiliser le paquetage profvis
. Il ne mesure pas seulement le temps d'exécution de votre code, mais vous donne un aperçu de chaque fonction que vous exécutez. Il peut également être utilisé pour Shiny.
library(profvis)
profvis({
#your code here
})
Cliquez ici pour quelques exemples.