R Academy · Lektion

Benchmarking med microbenchmark

Jämför flera implementationer statistiskt med microbenchmark().

Lektion 4 av 413 steg

Benchmarking med microbenchmark är en gratis lektion i R Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för R Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i R Academy innehåller totalt 4 lektioner.

Varför använda microbenchmark?

system.time() har millisekundupplösning och är opålitligt för snabba operationer. Paketet microbenchmark kör uttryck hundratals gånger, hanterar uppvärmning och rapporterar statistik med upplösning på nanosekundnivå — vilket gör det till rätt verktyg för att jämföra liknande implementationer.

Grundläggande användning av microbenchmark

Skicka namngivna uttryck till microbenchmark(). Namnet på varje argument blir etiketten i resultatet. Argumentet times styr hur många gånger varje uttryck utvärderas.

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

Välja argumentet times

Fler upprepningar ger stabilare uppskattningar men tar längre tid. Allmänna riktlinjer:

Snabba uttryck (mikrosekunder): times = 1000L eller fler
Medelsnabba uttryck (millisekunder): times = 100L
Långsamma uttryck (sekunder): times = 10L eller färre

Standardvärdet är times = 100L, vilket är en bra utgångspunkt.

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

Ange argumentet unit

Använd argumentet unit för att visa resultaten i en praktisk skala:

'ns' — nanosekunder (för mycket snabba operationer)
'us' — mikrosekunder
'ms' — millisekunder
's' — sekunder
'relative' — kvoten jämfört med det snabbaste uttrycket

# library(microbenchmark)
# x <- runif(1000)
#
# microbenchmark(
#   sapply_sqrt = sapply(x, sqrt),
#   vectorized  = sqrt(x),
#   times = 500L,
#   unit = 'us'   # display in microseconds
# )

Tolka sammanfattningen

microbenchmark skriver ut en sammanfattningstabell med följande kolumner:

min — den snabbaste enskilda körningen
lq / mean / median / uq — nedre kvartil, medelvärde, median, övre kvartil
max — den långsammaste enskilda körningen
neval — antal utvärderingar

Använd median som primärt jämförelsemått — den påverkas mindre av tillfälliga GC-pauser som kan höja maxvärdet och medelvärdet.

# 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() på ett microbenchmark-objekt

Om du anropar summary(mb) på ett sparat microbenchmark-resultat får du en data frame som du kan inspektera programmatiskt. Du kan även ändra unit i anropet till 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() för visuell jämförelse

autoplot(mb) använder ggplot2 för att rita ett violin- eller boxdiagram över tidsfördelningarna för de olika uttrycken. Då blir det enkelt att se inte bara skillnader i median utan även variation och överlappning mellan alternativen.

# 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

Jämföra loop, vapply och sapply

Ett klassiskt benchmark är att tillämpa en funktion element för element med en for-loop, sapply() eller vapply(). vapply() är snabbare än sapply() eftersom resultatvektorn förallokeras. Båda är långsammare än helt vektoriserad kod.

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

Kontrollera korrektheten först

Kontrollera före benchmarkingen att alla uttryck returnerar identiska resultat. En snabbare men felaktig implementation är värdelös. Använd identical() eller all.equal() för att jämföra resultaten.

# 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 med argumentet setup

Använd argumentet setup för att köra kod en gång före de tidtagna uttrycken. Då räknas inte tiden för att skapa data med i benchmarkingen när det inte är dataskapandet du mäter.

# 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

Rapportera benchmarkresultat i analyser

När du delar benchmarkresultat ska du alltid rapportera:

R-version och plattform
Versioner av paketen
Vilket värde på times som användes
Storleken på de data som benchmarkades

Tidsmätningar kan inte överföras direkt mellan datorer — rapportera kvoter i stället för absoluta tal när du jämför implementationer.

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

Snabbkontroll: mått i microbenchmark

Vilket sammanfattningsmått från resultatet av microbenchmark är mest tillförlitligt när två implementationer ska jämföras?

Besvara frågan i den interaktiva lektionen

Repetition av microbenchmark

microbenchmark är standardverktyget för noggrann mikrobenchmarking i R:

Skicka namngivna uttryck och ange times för att styra antalet upprepningar
Använd unit = 'us' eller 'ms' för lättlästa resultat
Jämför medianer — de påverkas mindre av GC-avvikelser
Använd autoplot() för att visualisera tidsfördelningar
Kontrollera korrektheten med all.equal() före benchmarkingen

Gratis att börja

Lär dig R med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 43
Lektioner: 159

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Benchmarking med microbenchmark” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen R Academy, inklusive ”Benchmarking med microbenchmark”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i R Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Benchmarking med microbenchmark”?

Jämför flera implementationer statistiskt med microbenchmark(). Ni övar på R Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig R Academy?

Du behöver inga förkunskaper. Utbildningen i R Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Benchmarking med microbenchmark”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här R Academy-lektionen?

Ja. Varje R Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till R Academy