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

282

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
dns
fonte
2
Eu acho que você tinha proc.timeem mente porque system.timeé uma que você precisa.
Marek
1
Para funções maiores, Rprofé bom. Ele fornece um perfil de todos os processos em uma parte / função de código.
Rich Scriven
38
Novos usuários do R que encontram essa pergunta no google: require(microbenchmark)agora é (há alguns anos) o caminho padrão da comunidade para cronometrar as coisas. times <- microbenchmark( lm(y~x), glm(y~x), times=1e3); example(microbenchmark). Isto faz uma estatística comparação de lmvs glmmais de 1000 tentativas, em vez de system.timetestar apenas uma vez.
Isomorphismes
use res <- microbenchmark(your code1,your code2)e depois print(res)para ver uma tabela ou ggplot2::autoplot(res)ver um boxplot! ref
Travis

Respostas:

253

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.

Shreyes
fonte
14
Isso é muito mais eficiente em termos de memória, então system.time (), que efetivamente copia seus argumentos. É importante quando você está lidando com dados que mal cabem na sua RAM.
Adam Ryczkowski
2
Para as pessoas que usam Sys.time, por favor, leia isto para uma advertência: Cronometrando o código R com Sys.time ()
>
1
system.time()foi mais rápido para mim. Eu acho que essa resposta system.time()deve ser aceita!
Gwang-Jin Kim
Esta é a minha maneira preferida de saber o tempo que leva para um longo cálculo feito em paralelo em vários núcleos. Nesse caso, o tempo do relógio de parede medido por meio dessa chamada é preciso o suficiente, pois o computador ficará muito mais ocupado com todos os núcleos calculados do que fazendo qualquer outra coisa e os cálculos levam minutos ou horas para serem concluídos. Este é um caso de uso muito específico, mas vale a pena mencionar.
Pablo Adames
186

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

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

Andrie
fonte
1
Importante saber é que system.time()possui um argumento gcFirstque é TRUEpor padrão. Isso, por um lado, torna a medição um pouco mais reproduzível, mas pode gerar uma sobrecarga significativa do tempo total de execução (que não é medido, é claro).
Jkob-r #
2
em que unidade isso é medido? por exemplo, eu apenas corri system.time(result <- myfunction(with, arguments))e obtive 187.564 como saída - isso é em segundos ou o quê?
precisa saber é o seguinte
Para as pessoas que usam system.time, por favor, leia isto para uma ressalva: erros de "objeto não encontrado" e "símbolo inesperado" ao cronometrar o código R com system.time () .
李哲源
@ zsad512 Tenho certeza de que são segundos .
Tapper
58

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

system.time( replicate(10000, myfunction(with,arguments) ) )
Sacha Epskamp
fonte
28
É melhor usar o pacote microbenchmark porque ele não inclui a sobrecarga da replicação no tempo.
Hadley
37

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

csgillespie
fonte
6
A marca Microbench é ainda melhor porque utiliza funções de sincronismo de precisão mais alta.
Hadley
4
@hadley Mas o rbenchmark é mais fácil de usar em caso de comparações. Para mim microbenchmark é atualizado system.time. rmicrobenchmark é o que precisamos :)
Marek
3
O mantenedor da marca microbench é bastante responsivo - aposto que ele adicionaria o que você precisasse.
91111
34

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.

Davor Josipovic
fonte
32

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 ...

Rodrigo de Alexandre
fonte
25

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
Anton
fonte
18

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))
TPArrow
fonte
2
Eu não conhecia o Rprof até agora e é realmente ótimo! Além disso, ele vem com a base R, portanto, não é necessário pacote extra como microbenchmarkou profvis.
Simon C.
Gostaria de saber se o rprof também pode ser visualizado, como, por exemplo, se queremos traçar o tempo de cada item que cria um perfil?
Zawir Amin
@ZawirAmin Existe uma maneira, basta usar o Rstudio >> menu de perfil
TPArrow
13

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.

gianni
fonte
11

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

Função de cronômetro em R

Richie Cotton
fonte
Estava prestes a adicionar proc.time()… Eu gosto mais do nome fofo. =)
isomorphismes