PricingLoginStart free
R Academy · Les

Benchmarking met microbenchmark

Vergelijk meerdere implementaties statistisch met microbenchmark().

Les 4 van 413 stappen

Benchmarking met microbenchmark is een gratis R Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject R Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus R Academy bevat in totaal 4 lessen.

Waarom microbenchmark?

system.time() heeft een resolutie van milliseconden en is onbetrouwbaar voor snelle bewerkingen. Het pakket microbenchmark voert expressies honderden keren uit, handelt het opwarmen af en rapporteert statistieken met een resolutie van nanoseconden — daardoor is het het juiste hulpmiddel om vergelijkbare implementaties te vergelijken.

microbenchmark in de basis gebruiken

Geef benoemde expressies door aan microbenchmark(). De naam van elk argument wordt het label in de uitvoer. Het argument times bepaalt hoe vaak elke expressie wordt geëvalueerd.

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

Het argument times kiezen

Meer herhalingen geven stabielere schattingen, maar duren langer. Algemene richtlijnen:

  • Snelle expressies (microseconden): times = 1000L of meer
  • Gemiddeld snel (milliseconden): times = 100L
  • Trage expressies (seconden): times = 10L of minder

De standaardwaarde is times = 100L, wat een goed uitgangspunt is.

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

Het argument unit opgeven

Gebruik het argument unit om resultaten op een handige schaal weer te geven:

  • 'ns' — nanoseconden (voor zeer snelle bewerkingen)
  • 'us' — microseconden
  • 'ms' — milliseconden
  • 's' — seconden
  • 'relative' — verhouding tot de snelste expressie
# library(microbenchmark)
# x <- runif(1000)
#
# microbenchmark(
#   sapply_sqrt = sapply(x, sqrt),
#   vectorized  = sqrt(x),
#   times = 500L,
#   unit = 'us'   # display in microseconds
# )

De samenvattingsuitvoer interpreteren

microbenchmark drukt een samenvattingstabel af met deze kolommen:

  • min — snelste afzonderlijke uitvoering
  • lq / mean / median / uq — eerste kwartiel, gemiddelde, mediaan, derde kwartiel
  • max — langzaamste afzonderlijke uitvoering
  • neval — aantal evaluaties

Gebruik median als belangrijkste vergelijkingsmaatstaf — deze is ongevoelig voor incidentele GC-pauzes die max en mean verhogen.

# 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() op een microbenchmarkobject

Als je summary(mb) aanroept op een opgeslagen microbenchmark-resultaat, krijg je een gegevensframe terug dat je programmatisch kunt onderzoeken. Je kunt ook de unit wijzigen in de aanroep van summary.

# 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() voor visuele vergelijking

autoplot(mb) gebruikt ggplot2 om een vioolplot of boxplot te tekenen van de tijdsverdelingen voor de expressies. Zo zie je eenvoudig niet alleen verschillen in de mediaan, maar ook de variatie en overlap tussen alternatieven.

# 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

Lus, vapply en sapply vergelijken

Een klassieke benchmark: een functie per element toepassen met een for-lus, sapply() of vapply(). vapply() is sneller dan sapply() omdat het de resultaatvector vooraf toewijst. Beide zijn trager dan volledig gevectoriseerde code.

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

Eerst de juistheid controleren

Controleer vóór het benchmarken of alle expressies identieke resultaten opleveren. Een snellere maar onjuiste implementatie is nutteloos. Gebruik identical() of all.equal() om uitvoer te vergelijken.

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

Benchmarken met het argument setup

Gebruik het argument setup om code één keer uit te voeren vóór de expressies waarvan de tijd wordt gemeten. Zo neem je de tijd voor het maken van gegevens niet mee in de benchmark wanneer juist dat maken van gegevens niet wordt gemeten.

# 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

Benchmarks rapporteren in een analyse

Wanneer je benchmarkresultaten deelt, rapporteer je altijd:

  • De R-versie en het platform
  • Pakketversies
  • De gebruikte waarde van times
  • De omvang van de gegevens waarop de benchmark is uitgevoerd

Tijdsmetingen zijn niet overdraagbaar tussen machines — rapporteer verhoudingen in plaats van absolute getallen wanneer je implementaties vergelijkt.

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

Snelle controle: microbenchmarkmaatstaf

Welke samenvattingsstatistiek uit de uitvoer van microbenchmark is het betrouwbaarst om twee implementaties te vergelijken?

Beantwoord dit in de interactieve les

Herhaling van microbenchmark

microbenchmark is het standaardhulpmiddel voor rigoureus microbenchmarken in R:

  • Geef benoemde expressies door en stel times in om het aantal herhalingen te bepalen
  • Gebruik unit = 'us' of 'ms' voor leesbare uitvoer
  • Vergelijk medianen — deze zijn ongevoelig voor GC-uitbijters
  • Gebruik autoplot() om tijdsverdelingen te visualiseren
  • Controleer de juistheid met all.equal() vóór het benchmarken
Gratis beginnen

Leer R met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
43
Lessen
159
Gratis beginnen met lerenBekijk de volledige cursus

Veelgestelde vragen

Is de les “Benchmarking met microbenchmark” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad R Academy, waaronder “Benchmarking met microbenchmark”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus R Academy bevat in totaal 4 lessen.

Wat leer ik in “Benchmarking met microbenchmark”?

Vergelijk meerdere implementaties statistisch met microbenchmark(). Je oefent met R Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met R Academy te beginnen?

Ervaring vooraf is niet nodig. R Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Benchmarking met microbenchmark”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over R Academy?

Ja. Elke les over R Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. system.time() en proc.time()
  2. Code profileren met Rprof en profvis
  3. Vectorisatie voor snelheid
  4. Benchmarking met microbenchmark
← Terug naar R Academy