Evaluación comparativa con microbenchmark
Compare estadísticamente varias implementaciones con microbenchmark().
Evaluación comparativa con microbenchmark es una lección gratuita de R Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.
¿Por qué microbenchmark?
system.time() tiene una resolución de milisegundos y no es fiable para operaciones rápidas. El paquete microbenchmark ejecuta las expresiones cientos de veces, gestiona el calentamiento y proporciona estadísticas con resolución de nanosegundos, por lo que es la herramienta adecuada para comparar implementaciones similares.
Uso básico de microbenchmark
Pase expresiones con nombre a microbenchmark(). El nombre de cada argumento se convierte en la etiqueta de la salida. El argumento times controla cuántas veces se evalúa cada expresión.
# library(microbenchmark)
# x <- 1:10000
#
# microbenchmark(
# loop = {
# s <- 0
# for (v in x) s <- s + v
# },
# vectorized = sum(x),
# times = 200L
# )Elección del argumento times
Más repeticiones proporcionan estimaciones más estables, pero requieren más tiempo. Orientaciones generales:
- Expresiones rápidas (microsegundos):
times = 1000Lo más - Expresiones moderadas (milisegundos):
times = 100L - Expresiones lentas (segundos):
times = 10Lo menos
El valor predeterminado es times = 100L, que es un buen punto de partida.
# library(microbenchmark)
# microbenchmark(
# fast_op = sqrt(2),
# times = 10000L # many reps for a nanosecond-scale operation
# )
# microbenchmark(
# slow_op = sort(rnorm(1e6)),
# times = 10L # fewer reps for second-scale operation
# )Especificación del argumento unit
Use el argumento unit para mostrar los resultados en una escala conveniente:
'ns'— nanosegundos (para operaciones muy rápidas)'us'— microsegundos'ms'— milisegundos's'— segundos'relative'— proporción respecto a la expresión más rápida
# library(microbenchmark)
# x <- runif(1000)
#
# microbenchmark(
# sapply_sqrt = sapply(x, sqrt),
# vectorized = sqrt(x),
# times = 500L,
# unit = 'us' # display in microseconds
# )Interpretación de la salida del resumen
microbenchmark imprime una tabla resumen con estas columnas:
- min — ejecución individual más rápida
- lq / mean / median / uq — cuartil inferior, media, mediana y cuartil superior
- max — ejecución individual más lenta
- neval — número de evaluaciones
Use median como métrica principal de comparación: es resistente a las pausas ocasionales del GC que aumentan los valores máximo y medio.
# Example summary output (unit: microseconds):
#
# expr min lq mean median uq max neval
# loop 1203.1 1245.3 1301.7 1262.4 1310.1 2100.8 100
# vectorized 2.1 2.3 2.9 2.4 2.6 18.3 100
#
# => vectorized is ~525x faster at median
cat('Always compare medians, not means, for microbenchmark results
')summary() en un objeto microbenchmark
Al llamar a summary(mb) sobre un resultado de microbenchmark almacenado, se devuelve un marco de datos que puede inspeccionar mediante programación. También puede cambiar unit en la llamada al resumen.
# library(microbenchmark)
# x <- rnorm(5000)
# mb <- microbenchmark(
# vapply_abs = vapply(x, abs, numeric(1)),
# base_abs = abs(x),
# times = 200L
# )
# s <- summary(mb, unit = 'ms')
# print(s[, c('expr', 'min', 'median', 'max')])autoplot() para la comparación visual
autoplot(mb) usa ggplot2 para dibujar un gráfico de violín o de cajas de las distribuciones de tiempos entre expresiones. Esto facilita observar no solo las diferencias de las medianas, sino también la variabilidad y el solapamiento entre alternativas.
# library(microbenchmark)
# library(ggplot2)
#
# x <- 1:50000
# mb <- microbenchmark(
# loop = { s <- 0; for (v in x) s <- s + v },
# vapply = vapply(x, identity, numeric(1)),
# vec = sum(x),
# times = 100L
# )
# autoplot(mb) # opens ggplot2 violin chartComparación entre for, vapply y sapply
Un benchmark clásico: aplicar una función elemento a elemento usando un bucle for, sapply() o vapply(). vapply() es más rápido que sapply() porque preasigna el vector de resultados. Ambos son más lentos que el código completamente vectorizado.
# library(microbenchmark)
# x <- runif(5000, 1, 100)
#
# mb <- microbenchmark(
# for_loop = {
# r <- numeric(length(x))
# for (i in seq_along(x)) r[i] <- log(x[i])
# },
# sapply_log = sapply(x, log),
# vapply_log = vapply(x, log, numeric(1)),
# vec_log = log(x),
# times = 200L, unit = 'us'
# )
# print(mb)Comprobación previa de la corrección
Antes de realizar el benchmark, verifique que todas las expresiones devuelvan resultados idénticos. Una implementación más rápida pero incorrecta no sirve de nada. Use identical() o all.equal() para comparar las salidas.
# x <- runif(1000)
# r1 <- sapply(x, sqrt)
# r2 <- sqrt(x)
# r3 <- vapply(x, sqrt, numeric(1))
#
# stopifnot(isTRUE(all.equal(r1, r2)))
# stopifnot(isTRUE(all.equal(r1, r3)))
# cat('All three produce identical results -- safe to benchmark
')
cat('Always verify correctness before comparing speed
')Benchmarking con el argumento setup
Use el argumento setup para ejecutar código una vez antes de cronometrar las expresiones. Así evita incluir el tiempo de creación de los datos en el benchmark cuando esa creación no es lo que está midiendo.
# library(microbenchmark)
#
# microbenchmark(
# sort_base = sort(x),
# sort_order = x[order(x)],
# setup = { x <- rnorm(10000) },
# times = 100L
# )
# Each iteration refreshes x via setup, then times sort_base and sort_orderPresentación de benchmarks en un análisis
Al compartir resultados de benchmarks, informe siempre de:
- La versión y la plataforma de R
- Las versiones de los paquetes
- El valor utilizado para
times - El tamaño de los datos del benchmark
Los tiempos no son transferibles entre máquinas; al comparar implementaciones, informe de proporciones y no de valores absolutos.
cat('R version :', R.version$version.string, '
')
cat('Platform :', R.version$platform, '
')
cat('Logical cores:', parallel::detectCores(), '
')Comprobación rápida: métrica de microbenchmark
¿Qué estadístico del resumen de la salida de microbenchmark es más fiable para comparar dos implementaciones?
Repaso de microbenchmark
microbenchmark es la herramienta estándar para realizar microbenchmarks rigurosos en R:
- Pase expresiones con nombre y establezca
timespara controlar las repeticiones - Use
unit = 'us'o'ms'para obtener una salida legible - Compare las medianas, ya que son resistentes a los valores atípicos del GC
- Use
autoplot()para visualizar las distribuciones de tiempos - Verifique la corrección con
all.equal()antes del benchmarking
Preguntas frecuentes
¿La lección «Evaluación comparativa con microbenchmark» es gratis?
Sí — el texto completo de «Evaluación comparativa con microbenchmark» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Evaluación comparativa con microbenchmark»?
Compare estadísticamente varias implementaciones con microbenchmark(). Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar R Academy?
No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Evaluación comparativa con microbenchmark»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de R Academy?
Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- system.time() y proc.time()
- Análisis de rendimiento del código con Rprof y profvis
- Vectorización para acelerar el código
- Evaluación comparativa con microbenchmark