R Academy · Leçon

set.seed() et reproductibilité

Garantissez la génération reproductible de nombres aléatoires entre les exécutions avec set.seed().

Leçon 1 sur 413 étapes

set.seed() et reproductibilité est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 1 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 la reproductibilité est importante

La génération de nombres aléatoires est pseudo-aléatoire : il s’agit d’un algorithme déterministe initialisé par une valeur de départ. La définition de la valeur de départ rend vos simulations reproductibles : le même code produit toujours les mêmes résultats, ce qui est essentiel pour le débogage, la publication et l’enseignement.

# Without set.seed: different every run
runif(3)  # e.g., 0.21, 0.57, 0.89 (changes each run)
runif(3)  # different again!

# With set.seed: always identical
set.seed(42)
runif(3)  # always: 0.9148060 0.9370754 0.2861395

set.seed(42)  # reset seed
runif(3)  # exactly the same three numbers again

cat('set.seed() is your reproducibility guarantee')

Mécanismes de set.seed()

set.seed(n) initialise l’état du générateur de nombres aléatoires (RNG). Tout entier positif convient. La valeur de départ détermine toute la séquence future de nombres aléatoires, jusqu’à sa réinitialisation. Utilisez une valeur fixe pour assurer la reproductibilité.

# Different seeds give different sequences
set.seed(1)
seq1 <- rnorm(5)

set.seed(99)
seq2 <- rnorm(5)

print(seq1)
print(seq2)
identical(seq1, seq2)  # FALSE

# Same seed always gives same sequence
set.seed(1)
seq1_again <- rnorm(5)
identical(seq1, seq1_again)  # TRUE

# Common seed choices
set.seed(123)   # popular convention
set.seed(2024)  # use year for temporal clarity

RNGkind() : algorithme du RNG

RNGkind() affiche ou définit l’algorithme du RNG. L’algorithme par défaut de R est Mersenne-Twister, avec la méthode de distribution normale Inversion. L’algorithme influe sur la séquence ; documentez donc la valeur de départ et RNGkind pour une reproductibilité complète.

# Check current RNG settings
RNGkind()
# [1] 'Mersenne-Twister' 'Inversion' 'Rejection'
# [1] kind, normal.kind, sample.kind

# Set explicitly for maximum reproducibility
RNGkind('Mersenne-Twister', 'Inversion', 'Rejection')
set.seed(42)
runif(3)

# Alternative RNG algorithms (rarely needed)
# RNGkind('L'Ecuyer-CMRG') # for parallel RNG
# RNGkind('Super-Duper')   # older algorithm

cat('Default Mersenne-Twister has period 2^19937 - 1')

Inspection de .Random.seed

.Random.seed est un vecteur global d’entiers qui stocke l’état complet du RNG. Il est automatiquement mis à jour après chaque tirage aléatoire. Vous pouvez l’enregistrer et le restaurer pour rejouer une séquence à partir de n’importe quel point.

set.seed(42)
# .Random.seed is created in .GlobalEnv after first use
length(.Random.seed)  # 626 integers for Mersenne-Twister
.Random.seed[1]       # encodes RNG type

# Generate one number (state advances)
x1 <- runif(1)
state_after <- .Random.seed

# Generate another
x2 <- runif(1)

# Restore state to after x1
.Random.seed <<- state_after
x2_replay <- runif(1)

identical(x2, x2_replay)  # TRUE - we replayed the state
cat('x2:', x2, 'x2_replay:', x2_replay)

Enregistrement et restauration de l’état du RNG

Enregistrez l’état du RNG avant un bloc de code, puis restaurez-le ultérieurement pour rejouer exactement ce bloc. Cette méthode est plus flexible que set.seed() lorsque vous devez reprendre une séquence en cours.

set.seed(100)
# Generate some random numbers first
runif(10)

# Save current state
saved_state <- .Random.seed

# Generate block of interest
block1 <- rnorm(5)
print(block1)

# ... later, restore and replay
.Random.seed <<- saved_state
block1_replay <- rnorm(5)

identical(block1, block1_replay)  # TRUE!
cat('RNG state saved and restored successfully')

RNG parallèle avec L'Ecuyer-CMRG

Lors de l'utilisation du calcul parallèle, chaque processus a besoin d'un flux RNG indépendant. Le générateur L'Ecuyer-CMRG fournit de longs flux qui ne se chevauchent pas pour les processus de travail parallèles, ce qui garantit l'indépendance des résultats entre les cœurs.

# Set up L'Ecuyer-CMRG for parallel use
RNGkind('L\'Ecuyer-CMRG')
set.seed(42)

# Each parallel worker gets its own stream
# (parallel package handles this automatically)
# library(parallel)
# cl <- makeCluster(4)
# clusterSetRNGStream(cl, iseed = 42)

# Generate numbers with this generator
samples <- rnorm(5)
print(samples)

# Reset to default Mersenne-Twister
RNGkind('Mersenne-Twister', 'Inversion', 'Rejection')
cat('L\'Ecuyer-CMRG: safe for parallel simulation')

Graine dans les appels de fonctions

Définir une graine à l'intérieur d'une fonction n'affecte pas l'état RNG de l'appelant après le retour de la fonction, car l'appel de définition de la graine modifie la valeur globale .Random.seed. Dans les fonctions réutilisables, gérez explicitement les graines.

# Function that optionally accepts a seed
simulate_data <- function(n, seed = NULL) {
  if (!is.null(seed)) set.seed(seed)
  list(
    x = rnorm(n),
    y = rnorm(n)
  )
}

# Reproducible call
result1 <- simulate_data(5, seed = 42)
result2 <- simulate_data(5, seed = 42)
identical(result1$x, result2$x)  # TRUE

# Without seed: different each time
result3 <- simulate_data(5)
result4 <- simulate_data(5)
identical(result3$x, result4$x)  # FALSE

Échantillonnage reproductible

L'argument sample.kind de RNGkind() concerne spécifiquement sample(). Depuis R 3.6.0, la valeur par défaut est devenue 'Rejection' pour améliorer l'uniformité : utilisez-la dans les traitements reproductibles.

# R 3.6+ default sample kind
RNGkind(sample.kind = 'Rejection')  # default
set.seed(42)
sample(1:10, 5)
# [1] 1 5 10 8 2  (with Rejection)

# Old behavior (R < 3.6) for legacy code
RNGkind(sample.kind = 'Rounding')
set.seed(42)
sample(1:10, 5)
# Different result!

# Best practice: reset to modern defaults
RNGkind('Mersenne-Twister', 'Inversion', 'Rejection')
set.seed(42)
sample(1:10, 5)

Documenter l'aléatoire

Bonne pratique pour une recherche reproductible : documentez votre version de R, la valeur de la graine et RNGkind. Utilisez sessionInfo() pour capturer l'intégralité de l'environnement. Enregistrez les graines dans les commentaires du script ou dans un fichier de configuration.

# Reproducibility header for analysis scripts:
# R version: R.version$version.string
# Seed: 42
# RNGkind: Mersenne-Twister / Inversion / Rejection

# Capture R version
R.version$version.string

# Capture full session info
# sessionInfo()  # shows all packages and versions

# In RMarkdown, set seed in setup chunk:
# ```{r setup}
# knitr::opts_chunk$set(echo = TRUE)
# set.seed(42)
# ```

# This ensures all chunks share the same RNG state
set.seed(42)
cat('R version:', R.version$version.string, '\n')
cat('Seed: 42, RNGkind: Mersenne-Twister')

Graines dans les études de Monte-Carlo

Dans les grandes études de simulation, utilisez une graine principale pour générer des graines propres à chaque réplication. Ainsi, chaque réplication est reproductible individuellement tout en conservant un plan global déterministe.

# Generate per-replicate seeds from a master seed
set.seed(2024)
n_replicates <- 5
replicate_seeds <- sample.int(1e6, n_replicates)
print(replicate_seeds)

# Each replicate uses its own seed
run_replicate <- function(rep_id) {
  set.seed(replicate_seeds[rep_id])
  mean(rnorm(1000))  # estimate with this seed
}

results <- sapply(seq_len(n_replicates), run_replicate)
print(round(results, 4))

# Any single replicate can be re-run independently:
set.seed(replicate_seeds[3])
mean(rnorm(1000))  # exactly matches results[3]

Tester l'aléatoire avec withr

Le paquet withr fournit with_seed(seed, expr), qui définit temporairement une graine, évalue l'expression, puis restaure l'état RNG initial : c'est idéal pour les tests sans polluer l'état global.

# withr::with_seed - restore RNG state automatically
# library(withr)
# result <- with_seed(42, rnorm(5))

# Simulation without withr (manual state save)
old_seed <- if (exists('.Random.seed')) .Random.seed
old_kind <- RNGkind()

set.seed(42)
result <- rnorm(5)

# Restore
if (!is.null(old_seed)) .Random.seed <<- old_seed
cat('Result:', result, '\n')
cat('Caller\'s RNG state preserved')

# set.seed in tests ensures deterministic assertions:
set.seed(1)
stopifnot(round(rnorm(1), 6) == round(-0.6264538, 6))

Vérification rapide

Vérifiez votre compréhension de la reproductibilité du RNG dans R.

Réponds-y dans la leçon interactive

Récapitulatif : graine et reproductibilité

Points clés : set.seed(n) rend le code aléatoire reproductible. RNGkind() affiche ou définit l'algorithme : documentez à la fois la graine et le type. .Random.seed stocke l'état RNG complet et peut être sauvegardé puis restauré. Pour le calcul parallèle, utilisez L'Ecuyer-CMRG. Dans les fonctions, acceptez un paramètre seed. Dans les grandes simulations, utilisez des graines propres à chaque réplication, générées à partir d'une graine principale.

# Reproducibility checklist:
# 1. Set seed at script top
set.seed(42)

# 2. Document RNGkind
RNGkind()  # Mersenne-Twister / Inversion / Rejection

# 3. Save RNG state if needed
saved <- .Random.seed

# 4. For functions, accept seed argument
my_sim <- function(n, seed = NULL) {
  if (!is.null(seed)) set.seed(seed)
  rnorm(n)
}

# 5. For parallel: use L'Ecuyer-CMRG
# RNGkind('L\'Ecuyer-CMRG'); set.seed(42)

cat('Reproducibility = trust in your results')

Gratuit pour commencer

Apprends R avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 43
Leçons: 159

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « set.seed() et reproductibilité » est-elle gratuite ?

Oui — le texte complet de « set.seed() et reproductibilité » 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 « set.seed() et reproductibilité » ?

Garantissez la génération reproductible de nombres aléatoires entre les exécutions avec set.seed(). 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 1 sur 4.

Combien de temps prend la leçon « set.seed() et reproductibilité » ?

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

← Retour à R Academy