set.seed() y reproducibilidad
Garantice la generación reproducible de números aleatorios entre ejecuciones con set.seed().
set.seed() y reproducibilidad es una lección gratuita de R Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.
Por qué importa la reproducibilidad
La generación de números aleatorios es pseudoaleatoria: un algoritmo determinista inicializado mediante un valor de partida. Establecer la semilla hace reproducibles las simulaciones: el mismo código siempre produce los mismos resultados, algo esencial para depurar, publicar y enseñar.
# 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')Mecánica de set.seed()
set.seed(n) inicializa el estado del generador de números aleatorios (RNG). Puede utilizar cualquier entero positivo. La semilla determina toda la secuencia futura de números aleatorios hasta que se restablezca. Use un número fijo para garantizar la reproducibilidad.
# 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 del RNG
RNGkind() muestra o establece el algoritmo del RNG. El valor predeterminado de R es Mersenne-Twister, con el método de distribución normal Inversion. El algoritmo afecta a la secuencia, por lo que debe documentar tanto la semilla como RNGkind para lograr una reproducibilidad completa.
# 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')Inspección de .Random.seed
.Random.seed es un vector global de enteros que almacena el estado completo del RNG. Se actualiza automáticamente después de cada extracción aleatoria. Puede guardarlo y restaurarlo para repetir una secuencia desde cualquier 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)Guardado y restauración del estado del RNG
Guarde el estado del RNG antes de un bloque de código y restáurelo después para repetir exactamente ese bloque. Es más flexible que set.seed() cuando necesita reanudar la secuencia desde un punto intermedio.
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 en paralelo con L'Ecuyer-CMRG
Al utilizar computación paralela, cada proceso necesita un flujo independiente de RNG. El generador L'Ecuyer-CMRG proporciona flujos largos que no se solapan para los trabajadores paralelos, lo que garantiza que los resultados sean independientes entre los núcleos.
# 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')Semillas en las llamadas a funciones
Establecer una semilla dentro de una función no afecta al estado de RNG del código que la llama después de que la función termina, porque la llamada a la semilla de la función modifica el valor global .Random.seed. Gestione explícitamente las semillas en las funciones reutilizables.
# 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) # FALSEMuestreo reproducible
El argumento sample.kind de RNGkind() afecta específicamente a sample(). Desde R 3.6.0, el valor predeterminado cambió a 'Rejection' para mejorar la uniformidad; utilice este valor en flujos de trabajo reproducibles.
# 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)Documentación de la aleatoriedad
Una buena práctica para la investigación reproducible es documentar la versión de R, el valor de la semilla y RNGkind. Utilice sessionInfo() para capturar el entorno completo. Registre las semillas en comentarios del script o en un archivo de configuración.
# 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')Semillas en estudios de Monte Carlo
En estudios de simulación grandes, utilice una única semilla maestra para generar semillas para cada réplica. Así, cada réplica se puede reproducir de forma independiente y el diseño general sigue siendo determinista.
# 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]Pruebas de aleatoriedad con withr
El paquete withr proporciona with_seed(seed, expr), que establece temporalmente una semilla, evalúa la expresión y después restaura el estado de RNG original; es perfecto para realizar pruebas sin contaminar el estado 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))Comprobación rápida
Compruebe su comprensión de la reproducibilidad de RNG en R.
Resumen: semillas y reproducibilidad
Ideas clave: set.seed(n) hace reproducible el código aleatorio. RNGkind() muestra o establece el algoritmo; documente tanto la semilla como el tipo. .Random.seed almacena el estado completo de RNG y se puede guardar y restaurar. Para la computación paralela, utilice L'Ecuyer-CMRG. En las funciones, acepte un parámetro seed. En simulaciones grandes, utilice semillas para cada réplica generadas a partir de una semilla maestra.
# 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')Preguntas frecuentes
¿La lección «set.seed() y reproducibilidad» es gratis?
Sí — el texto completo de «set.seed() y reproducibilidad» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.
¿Qué aprenderé en «set.seed() y reproducibilidad»?
Garantice la generación reproducible de números aleatorios entre ejecuciones con set.seed(). Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar R Academy?
No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «set.seed() y reproducibilidad»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de R Academy?
Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- set.seed() y reproducibilidad
- Generación de distribuciones aleatorias
- Fundamentos de la simulación de Monte Carlo
- Remuestreo bootstrap en R