Mesure du temps d'exécution d'une fonction en R

Existe-t-il un moyen normalisé dans R de mesurer le temps d'exécution d'une fonction?

Évidemment, je peux prendre system.timeavant et après l'exécution et ensuite prendre la différence de ceux-ci, mais je voudrais savoir s'il existe une méthode ou une fonction standardisée (je ne voudrais pas inventer la roue).

Je pense me souvenir d'avoir 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 possible de le 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, par rapport à la réponse ci-dessus, mais certainement une façon de le faire.

La fonction intégrée le system.time()fera.

Utilisez comme: system.time(result <- myfunction(with, arguments))

Comme l'a dit Andrie, ça system.time()marche bien. Pour une fonction courte je préfère y mettre replicate():

system.time( replicate(10000, myfunction(with,arguments) ) )

Une façon un peu plus agréable de mesurer le temps d'exécution consiste à utiliser le package rbenchmark . Ce package vous permet (facilement) de spécifier le nombre de fois pour répliquer votre test et la référence relative devrait être.

Voir également une question connexe sur stats.stackexchange

microbenchmark est un package léger (~ 50 Ko) et plus ou moins un moyen standard dans R pour 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, avec un temps d'exécution moyen d'environ 25-30 ns.

Il y a aussi proc.time()

Vous pouvez utiliser de la même manière que Sys.timemais cela vous donne 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 que la proc.time()méthode exécute toujours votre fonction au lieu de simplement mesurer le temps ... et au fait, j'aime utiliser system.timeavec {}inside pour que vous puissiez mettre un ensemble de choses ...

Le package "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 faire:

install.packages("tictoc")
require(tictoc)
tic()
rnorm(1000,0,1)
exectime <- toc()
exectime <- exectime$toc - exectime$tic

Bien que d'autres solutions soient utiles pour une seule fonction, je recommande le morceau de code suivant où il est plus général et efficace:

Rprof(tf <- "log.log", memory.profiling = TRUE)
# the code you want to profile must be in between
Rprof (NULL) ; print(summaryRprof(tf))

Un autre moyen simple mais très puissant de le faire est d'utiliser le package 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.

Vous pouvez utiliser de style Matlab tic- tocfonctions, si vous préférez. Voir cette autre question SO

Fonction chronomètre en R