Medindo o tempo de execução da função em R

Existe uma maneira padronizada em R de medir o tempo de execução da função?

Obviamente, eu posso pegar system.timeantes e depois da execução e depois tirar a diferença, mas gostaria de saber se existe alguma maneira ou função padronizada (gostaria de não inventar a roda).

Lembro-me de que já usei algo como abaixo:

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

Outra maneira possível de fazer isso seria usar Sys.time ():

start.time <- Sys.time()
...Relevent codes...
end.time <- Sys.time()
time.taken <- end.time - start.time
time.taken

Não é a maneira mais elegante de fazer isso, em comparação com a resposta acima, mas definitivamente uma maneira de fazê-lo.

A função system.time()interna fará isso.

Use como: system.time(result <- myfunction(with, arguments))

Como Andrie disse, system.time()funciona bem. Para uma função curta, prefiro colocar replicate()nela:

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

Uma maneira um pouco mais agradável de medir o tempo de execução é usar o pacote rbenchmark . Este pacote (facilmente) permite que você especifique quantas vezes replicar seu teste e qual deveria ser a referência relativa.

Consulte também uma pergunta relacionada em stats.stackexchange

microbenchmark é um pacote leve (~ 50kB) e mais ou menos uma maneira padrão no R para comparar várias expressões e funções:

microbenchmark(myfunction(with,arguments))

Por exemplo:

> 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

Aqui, ambas as expressões foram avaliadas 10000 vezes, com tempo médio de execução em torno de 25-30 ns.

Há também proc.time()

Você pode usar da mesma maneira que, Sys.timemas fornece um resultado semelhante ao system.time.

ptm <- proc.time()
#your function here
proc.time() - ptm

a principal diferença entre usar

system.time({ #your function here })

é que o proc.time()método ainda não executar a sua função em vez de apenas medir o tempo ... e por falar nisso, eu gosto de usar system.timecom {}dentro de modo que você pode colocar um conjunto de coisas ...

O pacote "tictoc" oferece uma maneira muito simples de medir o tempo de execução. A documentação está em: https://cran.fhcrc.org/web/packages/tictoc/tictoc.pdf .

install.packages("tictoc")
require(tictoc)
tic()
rnorm(1000,0,1)
toc()

Para economizar o tempo decorrido em uma variável, você pode:

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

Embora outras soluções sejam úteis para uma única função, recomendo o seguinte trecho de código, onde é mais geral e eficaz:

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

Outra maneira simples, mas muito poderosa de fazer isso, é usando o pacote profvis. Ele não mede apenas o tempo de execução do seu código, mas fornece um detalhamento para cada função que você executa. Também pode ser usado para o Shiny.

library(profvis)

profvis({
  #your code here
})

Clique aqui para alguns exemplos.

Você pode usar funções tic- estilo MATLAB toc, se preferir. Veja esta outra questão SO

Função de cronômetro em R