R Academy · Leçon

Évaluer les performances avec microbenchmark

Comparez statistiquement plusieurs implémentations avec microbenchmark().

Évaluer les performances avec microbenchmark est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Pourquoi utiliser microbenchmark ?

system.time() a une résolution à la milliseconde et n’est pas fiable pour les opérations rapides. Le paquet microbenchmark exécute les expressions des centaines de fois, gère la phase d’échauffement et fournit des statistiques à la nanoseconde près : c’est donc l’outil approprié pour comparer des implémentations similaires.

Utilisation de base de microbenchmark

Transmettez des expressions nommées à microbenchmark(). Le nom de chaque argument devient l’étiquette affichée dans le résultat. L’argument times contrôle le nombre d’évaluations de chaque expression.

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

Choisir la valeur de l’argument times

Un plus grand nombre de répétitions produit des estimations plus stables, mais demande davantage de temps. Voici quelques indications générales :

Expressions rapides (microsecondes) : times = 1000L ou davantage
Expressions modérément rapides (millisecondes) : times = 100L
Expressions lentes (secondes) : times = 10L ou moins

La valeur par défaut est times = 100L, ce qui constitue un bon point de départ.

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

Spécifier l’argument unit

Utilisez l’argument unit pour afficher les résultats sur une échelle pratique :

'ns' — nanosecondes (pour les opérations très rapides)
'us' — microsecondes
'ms' — millisecondes
's' — secondes
'relative' — rapport par rapport à l’expression la plus rapide

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

Interpréter le résultat récapitulatif

microbenchmark affiche un tableau récapitulatif contenant les colonnes suivantes :

min — exécution individuelle la plus rapide
lq / mean / median / uq — premier quartile, moyenne, médiane, troisième quartile
max — exécution individuelle la plus lente
neval — nombre d’évaluations

Utilisez median comme principale mesure de comparaison : elle résiste aux pauses occasionnelles du ramasse-miettes, qui augmentent max et mean.

# 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() sur un objet microbenchmark

L’appel de summary(mb) sur un résultat microbenchmark enregistré renvoie un bloc de données que vous pouvez examiner par programmation. Vous pouvez également modifier unit dans l’appel au résumé.

# 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() pour une comparaison visuelle

autoplot(mb) utilise ggplot2 pour tracer un diagramme en violon ou en boîte des distributions de temps d’exécution entre les expressions. Cela permet de voir facilement non seulement les différences de médiane, mais aussi la variabilité et le chevauchement entre les solutions.

# 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

Comparer une boucle, vapply et sapply

Voici une comparaison classique : appliquer une fonction élément par élément avec une boucle for, sapply() ou vapply(). vapply() est plus rapide que sapply(), car il préalloue le vecteur de résultats. Les deux sont plus lentes qu’un code entièrement vectorisé.

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

Vérifier d’abord la correction

Avant de mesurer les performances, vérifiez que toutes les expressions renvoient des résultats identiques. Une implémentation plus rapide mais incorrecte ne sert à rien. Utilisez identical() ou all.equal() pour comparer les sorties.

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

Mesurer les performances avec l’argument setup

Utilisez l’argument setup pour exécuter du code une fois avant les expressions chronométrées. Cela évite d’inclure le temps de création des données dans la mesure lorsque cette création n’est pas ce que vous cherchez à mesurer.

# 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

Présenter les mesures dans une analyse

Lorsque vous partagez des résultats de mesure, indiquez toujours :

La version de R et la plateforme
Les versions des paquets
La valeur utilisée pour times
La taille des données mesurées

Les temps d’exécution ne sont pas transposables d’une machine à l’autre : indiquez les rapports plutôt que les valeurs absolues lorsque vous comparez des implémentations.

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

Vérification rapide : mesure de microbenchmark

Quelle statistique récapitulative issue du résultat de microbenchmark est la plus fiable pour comparer deux implémentations ?

Récapitulatif de microbenchmark

microbenchmark est l’outil standard pour mesurer rigoureusement de petites performances dans R :

Transmettez des expressions nommées et définissez times pour contrôler le nombre de répétitions
Utilisez unit = 'us' ou 'ms' pour obtenir un affichage lisible
Comparez les médianes : elles résistent aux valeurs atypiques du ramasse-miettes
Utilisez autoplot() pour visualiser les distributions de temps d’exécution
Vérifiez la correction avec all.equal() avant les mesures

Questions Fréquemment Posées

La leçon « Évaluer les performances avec microbenchmark » est-elle gratuite ?

Oui — le texte complet de « Évaluer les performances avec microbenchmark » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Évaluer les performances avec microbenchmark » ?

Comparez statistiquement plusieurs implémentations avec microbenchmark(). Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Évaluer les performances avec microbenchmark » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

system.time() et proc.time()
Profiler du code avec Rprof et profvis
Vectorisation pour accélérer le code
Évaluer les performances avec microbenchmark

← Retour à R Academy