set.seed() e riproducibilità
Garantisca la generazione riproducibile di numeri casuali tra un'esecuzione e l'altra con set.seed()
set.seed() e riproducibilità è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.
Perché la riproducibilità è importante
La generazione di numeri casuali è pseudo-casuale: utilizza un algoritmo deterministico inizializzato da un valore di partenza. Impostare il seed rende le simulazioni riproducibili: lo stesso codice produce sempre gli stessi risultati, un aspetto essenziale per il debugging, la pubblicazione e l'insegnamento.
# 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')Meccanismo di set.seed()
set.seed(n) inizializza lo stato del generatore di numeri casuali (RNG). È valido qualsiasi intero positivo. Il seed determina l'intera sequenza futura di numeri casuali finché il seed non viene reimpostato. Utilizzi un numero fisso per garantire la riproducibilità.
# 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 clarityRNGkind(): algoritmo RNG
RNGkind() mostra o imposta l'algoritmo RNG. Il valore predefinito di R è Mersenne-Twister, con il metodo Inversion per la distribuzione normale. L'algoritmo influisce sulla sequenza; per una riproducibilità completa, documenti sia il seed sia RNGkind.
# 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')Ispezione di .Random.seed
.Random.seed è un vettore globale di interi che memorizza l'intero stato dell'RNG. Viene aggiornato automaticamente dopo ogni estrazione casuale. Può salvarlo e ripristinarlo per riprodurre una sequenza a partire da qualsiasi punto.
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)Salvataggio e ripristino dello stato RNG
Salvi lo stato RNG prima di un blocco di codice, quindi lo ripristini in seguito per riprodurre esattamente quel blocco. È più flessibile di set.seed() quando deve riprendere l'esecuzione a metà di una sequenza.
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 parallelo con L'Ecuyer-CMRG
Quando si utilizza il calcolo parallelo, ogni processo richiede un flusso RNG indipendente. Il generatore L'Ecuyer-CMRG fornisce flussi lunghi e non sovrapposti per i worker paralleli, garantendo risultati indipendenti tra i core.
# 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')Impostare il seed nelle chiamate di funzione
Impostare un seed all'interno di una funzione non influisce sullo stato RNG del chiamante dopo la restituzione della funzione, perché la chiamata al seed modifica .Random.seed globale. Nelle funzioni riutilizzabili, gestisca esplicitamente i seed.
# 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) # FALSECampionamento riproducibile
L'argomento sample.kind di RNGkind() influisce nello specifico su sample(). A partire da R 3.6.0, il valore predefinito è cambiato in 'Rejection' per una migliore uniformità: lo utilizzi nei flussi di lavoro riproducibili.
# 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)Documentare la casualità
Una buona pratica per la ricerca riproducibile consiste nel documentare la versione di R, il valore del seed e RNGkind. Utilizzi sessionInfo() per acquisire l'intero ambiente. Registri i seed nei commenti dello script o in un file di configurazione.
# 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')Seed negli studi Monte Carlo
Negli studi di simulazione di grandi dimensioni, utilizzi un singolo seed principale per generare i seed delle singole repliche. In questo modo ogni replica è riproducibile individualmente, mantenendo deterministico il disegno complessivo.
# 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]Testare la casualità con withr
Il pacchetto withr fornisce with_seed(seed, expr), che imposta temporaneamente un seed, valuta l'espressione e poi ripristina lo stato RNG originale: è perfetto per i test, senza contaminare lo stato globale.
# 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))Verifica rapida
Verifichi la Sua comprensione della riproducibilità degli RNG in R.
Riepilogo: seed e riproducibilità
Punti chiave: set.seed(n) rende riproducibile il codice casuale. RNGkind() visualizza o imposta l'algoritmo: documenti sia il seed sia il tipo. .Random.seed memorizza l'intero stato RNG e può essere salvato e ripristinato. Per il calcolo parallelo, utilizzi L'Ecuyer-CMRG. Nelle funzioni, accetti un parametro seed. Nelle simulazioni di grandi dimensioni, utilizzi seed per replica generati a partire da un seed 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')
Impara R con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 43
- Lezioni
- 159
Domande Frequenti
La lezione «set.seed() e riproducibilità» è gratuita?
Sì — il testo completo di «set.seed() e riproducibilità» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.
Cosa imparerò in «set.seed() e riproducibilità»?
Garantisca la generazione riproducibile di numeri casuali tra un'esecuzione e l'altra con set.seed() Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare R Academy?
Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «set.seed() e riproducibilità»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione R Academy?
Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- set.seed() e riproducibilità
- Generazione di distribuzioni casuali
- Fondamenti della simulazione Monte Carlo
- Ricampionamento bootstrap in R