R Language
Código de perfil

Hora del sistema

La hora del sistema le da el tiempo de CPU necesario para ejecutar una expresión R, por ejemplo:

system.time(print("hello world"))

# [1] "hello world"
#    user  system elapsed 
#       0       0       0 

Puede agregar piezas de código más grandes mediante el uso de llaves:

system.time({
    library(numbers)
    Primes(1,10^5)
})

O utilízalo para probar funciones:

fibb <- function (n) {   
    if (n < 3) {
        return(c(0,1)[n])
    } else {
        return(fibb(n - 2) + fibb(n -1))
    }
}

system.time(fibb(30))

proc.time ()

En su forma más simple, proc.time() proporciona el tiempo total transcurrido de la CPU en segundos para el proceso actual. Al ejecutarlo en la consola se obtiene el siguiente tipo de salida:

proc.time()

#       user     system    elapsed 
#    284.507    120.397 515029.305 

Esto es particularmente útil para la evaluación comparativa de líneas específicas de código. Por ejemplo:

t1 <- proc.time()
fibb <- function (n) {
    if (n < 3) {
        return(c(0,1)[n])
    } else {
        return(fibb(n - 2) + fibb(n -1))
    }
}
print("Time one")
print(proc.time() - t1)

t2 <- proc.time()
fibb(30)

print("Time two")
print(proc.time() - t2)

Esto da el siguiente resultado:

source('~/.active-rstudio-document')

# [1] "Time one"
#    user  system elapsed 
#       0       0       0 

# [1] "Time two"
#    user  system elapsed 
#   1.534   0.012   1.572 

system.time() es un contenedor para proc.time() que devuelve el tiempo transcurrido para un comando / expresión particular.

print(t1 <- system.time(replicate(1000,12^2)))
##  user  system elapsed 
## 0.000   0.000   0.002 

Tenga en cuenta que el objeto devuelto, de la clase proc.time , es un poco más complicado de lo que parece en la superficie:

str(t1)
## Class 'proc_time'  Named num [1:5] 0 0 0.002 0 0
##  ..- attr(*, "names")= chr [1:5] "user.self" "sys.self" "elapsed" "user.child" ...

Perfil de línea

Un paquete para el perfil de línea es lineprof, escrito y mantenido por Hadley Wickham. Aquí hay una demostración rápida de cómo funciona con auto.arima en el paquete de pronóstico:

library(lineprof)
library(forecast)

l <- lineprof(auto.arima(AirPassengers))
shine(l)

Esto le proporcionará una aplicación brillante, que le permite profundizar en cada llamada de función. Esto le permite ver con facilidad lo que está causando que su código R se ralentice. Hay una captura de pantalla de la aplicación brillante a continuación:

Microbenchmark

Microbenchmark es útil para estimar la toma de tiempo para procedimientos rápidos. Por ejemplo, considere estimar el tiempo que se tarda en imprimir hola mundo.

system.time(print("hello world"))

# [1] "hello world"
#    user  system elapsed 
#       0       0       0 

Esto se debe a que system.time es esencialmente una función de envoltorio para proc.time , que mide en segundos. Como la impresión de "hola mundo" toma menos de un segundo, parece que el tiempo empleado es inferior a un segundo, pero esto no es cierto. Para ver esto podemos usar el paquete microbenchmark:

library(microbenchmark)
microbenchmark(print("hello world"))
 
# Unit: microseconds
#                 expr    min     lq     mean  median     uq     max neval
# print("hello world") 26.336 29.984 44.11637 44.6835 45.415 158.824   100

Aquí podemos ver después de ejecutar la print("hello world") 100 veces, el tiempo promedio empleado fue de 44 microsegundos. (Tenga en cuenta que ejecutar este código imprimirá "hello world" 100 veces en la consola.)

Podemos comparar esto con un procedimiento equivalente, cat("hello world\n") , para ver si es más rápido que print("hello world") :

microbenchmark(cat("hello world\n"))

# Unit: microseconds
#                  expr    min      lq     mean median     uq     max neval
# cat("hello world\\n") 14.093 17.6975 23.73829 19.319 20.996 119.382   100

En este caso, cat() es casi el doble de rápido que print() .

Alternativamente, se pueden comparar dos procedimientos dentro de la misma llamada de microbenchmark :

microbenchmark(print("hello world"), cat("hello world\n"))
# Unit: microseconds
# expr                    min     lq     mean  median     uq     max neval
# print("hello world") 29.122 31.654 39.64255 34.5275 38.852 192.779   100
# cat("hello world\\n")  9.381 12.356 13.83820 12.9930 13.715  52.564   100

Benchmarking utilizando microbenchmark

Puede usar el paquete microbenchmark para llevar a cabo el "momento preciso de la evaluación de la expresión" en milisegundos.

En este ejemplo , estamos comparando las velocidades de seis expresiones de data.table equivalentes para actualizar elementos en un grupo, en función de una determinada condición.

Más específicamente:

Una data.table con 3 columnas: id , time y status . Para cada ID, quiero encontrar el registro con el tiempo máximo; luego, si para ese registro si el estado es verdadero, quiero establecerlo en falso si el tiempo es> 7

library(microbenchmark)
library(data.table)

set.seed(20160723)
dt <- data.table(id = c(rep(seq(1:10000), each = 10)),
                time = c(rep(seq(1:10000), 10)),
                status = c(sample(c(TRUE, FALSE), 10000*10, replace = TRUE)))
setkey(dt, id, time)  ## create copies of the data so the 'updates-by-reference' don't affect other expressions
dt1 <- copy(dt)
dt2 <- copy(dt)
dt3 <- copy(dt)
dt4 <- copy(dt)
dt5 <- copy(dt)
dt6 <- copy(dt)

microbenchmark(
  
  expression_1 = {
    dt1[ dt1[order(time), .I[.N], by = id]$V1, status := status * time < 7 ] 
    },
  
  expression_2 = {
    dt2[,status := c(.SD[-.N, status], .SD[.N, status * time > 7]), by = id]
    },
  
  expression_3 = {
    dt3[dt3[,.N, by = id][,cumsum(N)], status := status * time > 7]
    },
  
  expression_4 = { 
    y <- dt4[,.SD[.N],by=id]
    dt4[y, status := status & time > 7]
  },
  
  expression_5 = {
    y <- dt5[, .SD[.N, .(time, status)], by = id][time > 7 & status]
    dt5[y, status := FALSE]
  },
  
  expression_6 = {
    dt6[ dt6[, .I == .I[which.max(time)], by = id]$V1 & time > 7, status := FALSE]
    },
  
  times = 10L ## specify the number of times each expression is evaluated
)

# Unit: milliseconds
#         expr         min          lq        mean      median         uq          max neval
# expression_1   11.646149   13.201670   16.808399   15.643384   18.78640    26.321346    10
# expression_2 8051.898126 8777.016935 9238.323459 8979.553856 9281.93377 12610.869058    10
# expression_3    3.208773    3.385841    4.207903    4.089515    4.70146     5.654702    10
# expression_4   15.758441   16.247833   20.677038   19.028982   21.04170    36.373153    10
# expression_5 7552.970295 8051.080753 8702.064620 8861.608629 9308.62842  9722.234921    10
# expression_6   18.403105   18.812785   22.427984   21.966764   24.66930    28.607064    10

La salida muestra que en esta prueba la expression_3 es la más rápida.

Referencias

data.table - Añadir y modificar columnas

data.table - símbolos de agrupación especiales en data.table