0Pricing
R Academy · Aula

Avaliação de desempenho com microbenchmark

Compare estatisticamente várias implementações com microbenchmark().

Avaliação de desempenho com microbenchmark é uma aula grátis de R Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

Por que usar microbenchmark?

system.time() tem resolução de milissegundos e não é confiável para operações rápidas. O pacote microbenchmark executa expressões centenas de vezes, lida com o aquecimento e relata estatísticas com resolução de nanossegundos — o que o torna a ferramenta adequada para comparar implementações semelhantes.

Uso básico de microbenchmark

Passe expressões nomeadas para microbenchmark(). O nome de cada argumento se torna o rótulo na saída. O argumento times controla quantas vezes cada expressão é avaliada.

# library(microbenchmark)
# x <- 1:10000
#
# microbenchmark(
#   loop = {
#     s <- 0
#     for (v in x) s <- s + v
#   },
#   vectorized = sum(x),
#   times = 200L
# )

Escolhendo o argumento times

Mais repetições produzem estimativas mais estáveis, mas demoram mais. Orientações gerais:

  • Expressões rápidas (microssegundos): times = 1000L ou mais
  • Expressões moderadas (milissegundos): times = 100L
  • Expressões lentas (segundos): times = 10L ou menos

O padrão é times = 100L, um bom ponto 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
# )

Especificando o argumento unit

Use o argumento unit para exibir os resultados em uma escala conveniente:

  • 'ns' — nanossegundos (para operações muito rápidas)
  • 'us' — microssegundos
  • 'ms' — milissegundos
  • 's' — segundos
  • 'relative' — proporção em relação à expressão mais rápida
# library(microbenchmark)
# x <- runif(1000)
#
# microbenchmark(
#   sapply_sqrt = sapply(x, sqrt),
#   vectorized  = sqrt(x),
#   times = 500L,
#   unit = 'us'   # display in microseconds
# )

Interpretando a saída do resumo

microbenchmark imprime uma tabela-resumo com estas colunas:

  • min — execução individual mais rápida
  • lq / mean / median / uq — primeiro quartil, média, mediana, terceiro quartil
  • max — execução individual mais lenta
  • neval — número de avaliações

Use median como principal métrica de comparação — ela é resistente a pausas ocasionais do GC que aumentam os valores máximo e médio.

# 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() em um objeto microbenchmark

Chamar summary(mb) em um resultado microbenchmark armazenado retorna um quadro de dados que pode ser inspecionado programaticamente. Também é possível alterar o unit na chamada de resumo.

# 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 comparação visual

autoplot(mb) usa ggplot2 para desenhar um gráfico de violino ou de caixa das distribuições dos tempos entre as expressões. Isso facilita observar não apenas as diferenças entre medianas, mas também a variabilidade e a sobreposição entre as 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 chart

Comparando loop, vapply e sapply

Um teste clássico: aplicar uma função elemento a elemento usando um loop for, sapply() ou vapply(). vapply() é mais rápido do que sapply() porque faz a pré-alocação do vetor de resultados. Ambos são mais lentos do que código totalmente vetorizado.

# 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)

Verificando a correção primeiro

Antes de medir o desempenho, verifique se todas as expressões retornam resultados idênticos. Uma implementação mais rápida, mas incorreta, não serve para nada. Use identical() ou all.equal() para comparar as saídas.

# 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
')

Medindo o desempenho com o argumento setup

Use o argumento setup para executar o código uma vez antes das expressões cronometradas. Isso evita incluir o tempo de criação dos dados no teste quando a criação dos dados não é o que está sendo medido.

# 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_order

Relatando medições de desempenho na análise

Ao compartilhar resultados de medições de desempenho, sempre informe:

  • A versão e a plataforma do R
  • As versões dos pacotes
  • O valor de times usado
  • O tamanho dos dados medidos

Os tempos não são comparáveis entre máquinas — informe proporções, e não números absolutos, ao comparar implementações.

cat('R version    :', R.version$version.string, '
')
cat('Platform     :', R.version$platform, '
')
cat('Logical cores:', parallel::detectCores(), '
')

Verificação rápida: métrica do microbenchmark

Qual estatística-resumo da saída de microbenchmark é mais confiável para comparar duas implementações?

Recapitulação do microbenchmark

microbenchmark é a ferramenta padrão para medições rigorosas de desempenho em pequena escala no R:

  • Passe expressões nomeadas e defina times para controlar as repetições
  • Use unit = 'us' ou 'ms' para obter uma saída legível
  • Compare as medianas — elas são resistentes a valores atípicos do GC
  • Use autoplot() para visualizar as distribuições dos tempos
  • Verifique a correção com all.equal() antes de medir o desempenho

Perguntas Frequentes

A aula “Avaliação de desempenho com microbenchmark” é grátis?

Sim — o texto completo de “Avaliação de desempenho com microbenchmark” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Avaliação de desempenho com microbenchmark”?

Compare estatisticamente várias implementações com microbenchmark(). Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Avaliação de desempenho com microbenchmark”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. system.time() e proc.time()
  2. Criação de perfis de código com Rprof e profvis
  3. Vetorização para obter velocidade
  4. Avaliação de desempenho com microbenchmark
← Voltar para R Academy