R Academy · Lektion

Benchmarking med microbenchmark

Sammenlign flere implementeringer statistisk med microbenchmark().

Lektion 4 af 413 trin

Benchmarking med microbenchmark er en gratis R Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i R Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. R Academy-kurset indeholder 4 lektioner i alt.

Hvorfor microbenchmark?

system.time() har millisekundopløsning og er upålidelig ved hurtige operationer. Pakken microbenchmark kører udtryk hundredvis af gange, håndterer opvarmning og rapporterer statistik med nanosekundopløsning — hvilket gør den til det rigtige værktøj til at sammenligne lignende implementationer.

Grundlæggende brug af microbenchmark

Giv navngivne udtryk som argumenter til microbenchmark(). Navnet på hvert argument bliver etiketten i outputtet. Argumentet times styrer, hvor mange gange hvert udtryk evalueres.

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

Valg af argumentet times

Flere gentagelser giver mere stabile estimater, men tager længere tid. Generelle retningslinjer:

Hurtige udtryk (mikrosekunder): times = 1000L eller mere
Mellemhastige udtryk (millisekunder): times = 100L
Langsomme udtryk (sekunder): times = 10L eller færre

Standardværdien er times = 100L, hvilket er et godt udgangspunkt.

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

Angivelse af argumentet unit

Brug argumentet unit til at vise resultater i en praktisk skala:

'ns' — nanosekunder (til meget hurtige operationer)
'us' — mikrosekunder
'ms' — millisekunder
's' — sekunder
'relative' — forholdet til det hurtigste udtryk

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

Fortolkning af opsummeringsoutput

microbenchmark udskriver en opsummeringstabel med disse kolonner:

min — den hurtigste enkelte kørsel
lq / mean / median / uq — nedre kvartil, gennemsnit, median, øvre kvartil
max — den langsomste enkelte kørsel
neval — antal evalueringer

Brug median som det primære sammenligningsmål — den er robust over for lejlighedsvise GC-pauser, som øger max- og gennemsnitsværdien.

# 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å et microbenchmark-objekt

Hvis du kalder summary(mb) på et gemt microbenchmark-resultat, returneres en data frame, som du kan undersøge programmatisk. Du kan også ændre unit i kaldet til opsummeringen.

# 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() til visuel sammenligning

autoplot(mb) bruger ggplot2 til at tegne et violin- eller boksplot over tidsfordelingerne for de forskellige udtryk. Det gør det nemt at se ikke kun forskelle i medianen, men også variation og overlap mellem alternativerne.

# 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

Sammenligning af loop, vapply og sapply

Et klassisk benchmark: anvendelse af en funktion element for element med en for-løkke, sapply() eller vapply(). vapply() er hurtigere end sapply(), fordi den forhåndsallokerer resultatvektoren. Begge er langsommere end fuldt vektoriseret kode.

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

Kontrollér korrektheden først

Før du kører benchmark, skal du kontrollere, at alle udtryk returnerer identiske resultater. En hurtigere, men forkert implementation er ubrugelig. Brug identical() eller all.equal() til at sammenligne output.

# 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

Brug argumentet setup til at køre kode én gang før de tidsmålte udtryk. På den måde medregnes tiden til oprettelse af data ikke i benchmarkresultatet, når det ikke er dataoprettelsen, du måler.

# 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

Rapportering af benchmarkresultater i en analyse

Når du deler benchmarkresultater, skal du altid rapportere:

R-versionen og platformen
Pakkeversionerne
Den anvendte værdi for times
Størrelsen på de data, der blev benchmarked

Tidsmålinger kan ikke overføres direkte mellem maskiner — rapportér forholdstal i stedet for absolutte tal, når du sammenligner implementationer.

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

Hurtigt tjek: microbenchmark-metrik

Hvilken opsummeringsstatistik fra outputtet fra microbenchmark er mest pålidelig til at sammenligne to implementationer?

Besvar den i den interaktive lektion

Opsummering af microbenchmark

microbenchmark er standardværktøjet til grundig mikrobenchmarking i R:

Giv navngivne udtryk som argumenter, og indstil times for at styre antallet af gentagelser
Brug unit = 'us' eller 'ms' for et læsbart output
Sammenlign medianer — de er robuste over for GC-afvigere
Brug autoplot() til at visualisere tidsfordelinger
Kontrollér korrektheden med all.equal() før benchmarking

Gratis at komme i gang

Lær R med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 43
Lektioner: 159

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Benchmarking med microbenchmark” gratis?

Ja — alle 3 lektioner i læringssporet R Academy, inklusive “Benchmarking med microbenchmark”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. R Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Benchmarking med microbenchmark”?

Sammenlign flere implementeringer statistisk med microbenchmark(). Du øver dig i R Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på R Academy?

Der kræves ingen tidligere erfaring. R Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Benchmarking med microbenchmark”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne R Academy-lektion?

Ja. Alle R Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

system.time() og proc.time()
Profilering af kode med Rprof og profvis
Vektorisering for højere hastighed
Benchmarking med microbenchmark

← Tilbage til R Academy