obtenir le temps d'exécution en millisecondes dans la R

J'ai lu une solution à cela en utilisant tic(), toc() functions

tic <- function(gcFirst = TRUE, type=c("elapsed", "user.self", "sys.self"))
{
   type <- match.arg(type)
   assign(".type", type, envir=baseenv())
   if(gcFirst) gc(FALSE)
   tic <- proc.time()[type]         
   assign(".tic", tic, envir=baseenv())
   invisible(tic)
}

toc <- function()
{
   type <- get(".type", envir=baseenv())
   toc <- proc.time()[type]
   tic <- get(".tic", envir=baseenv())
   print(toc - tic)
   invisible(toc)
}




tic();
-----code----
toc();


elapsed 
   0.15

Mais je voudrais passer un beaucoup de précision dans millisecondes?

Aussi j'ai été en utilisant cette

ptm <- proc.time()
---code
proc.time() - ptm

et obtenir ce

   user  system elapsed 
   1.55    0.25    1.84

Comment obtenir plus de décimales ou plus de précision?

À partir de la page d'aide pour proc.time: "La résolution de la ces horaires seront spécifiques au système et sur Unix-sosies fois arrondies à l'entier le plus proche de 1ms."

InformationsquelleAutor cMinor | 2011-09-25

33

1) le Calendrier est dépendante du système d'exploitation. Sur Windows, vous pouvez seulement obtenir millisecondes.

2) Aucun besoin de définir tic() et toc(), R a system.time(). Voici un exemple:
```
R> system.time(replicate(100, sqrt(seq(1.0, 1.0e6))))
   user  system elapsed 
  2.210   0.650   2.867 
R> 
```
3) Il y a d'excellents add-on des paquets rbenchmark et microbenchmark.

3.1) rbenchmark est particulièrement utile pour la comparaison de commandes, mais peut également être utilisé directement:
```
R> library(rbenchmark)
R> x <- seq(1.0, 1.0e6); benchmark(sqrt(x), log(x))
     test replications elapsed relative user.self sys.self user.child sys.child
2  log(x)          100   5.408  2.85835      5.21     0.19          0         0
1 sqrt(x)          100   1.892  1.00000      1.62     0.26          0         0
R>
```
3.2) microbenchmark excelle dans la plus haute précision des mesures:
```
R> library(microbenchmark)
R> x <- seq(1.0, 1.0e6); microbenchmark(sqrt(x), log(x))
Unit: nanoseconds
     expr      min       lq   median       uq      max
1  log(x) 50589289 50703132 55283301 55353594 55917216
2 sqrt(x) 15309426 15412135 15452990 20011418 39551819
R> 
```
et ce dernier, en particulier sur Linux, vous donne déjà nano-secondes. Il peut également tracé des résultats etc, donc regarder de plus près à ce paquet.
- Si je n'ai plus qu'une seule ligne de code que je voudrais mesurer comment puis-je utiliser system.time(replicate(1000, ----several lines of code------ )) ?
- Ne pourriez-vous joindre à ces lignes de code dans { ... }?
- ha, oui, vous avez raison
InformationsquelleAutor Dirk Eddelbuettel
6

Cette une seule est bonne:
```
options(digits.secs = 6) # This is set so that milliseconds are displayed

start.time <- Sys.time()

...Relevant code...

end.time <- Sys.time()
time.taken <- end.time - start.time
time.taken
```
Prises de ici.
- Ce ne sera pas fournir le temps d'exécution précis à la milliseconde. La réponse est tout simplement une copie d'un autre, sauf que la réponse est plus approprié pour la question.
- Hmmm... Étrange 🙂 je viens de chronométrés mon propre code et le résultat a été: "la différence de Temps de 1.47222 secs" Maintenant, je suis curieux de savoir ce que les millisecondes sont, à votre avis?
- Vous avez besoin d'options(chiffres.s=6) pour voir Sys.time() ne contiennent de l'ordre de la milliseconde de données. Si pas, il n'affiche que le deuxième niveau de données, qui embrouiller les gens en pensant que ce n'est pas la milliseconde info.
InformationsquelleAutor Denis Rasulev

Place start_time avant votre code et end_time après votre code.

c'est à dire

start_time <- as.numeric(as.numeric(Sys.time())*1000, digits=15) # place at start

-----code----

end_time <- as.numeric(as.numeric(Sys.time())*1000, digits=15) # place at end

end_time - start_time    # run time (in milliseconds)

InformationsquelleAutor user5783745

Vous devez vous connecter pour publier un commentaire.