set.seed() e reprodutibilidade
Garanta a geração reproduzível de números aleatórios entre as execuções com set.seed().
set.seed() e reprodutibilidade é uma aula grátis de R Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.
Por que a reprodutibilidade é importante
A geração de números aleatórios é pseudoaleatória: um algoritmo determinístico inicializado por um valor inicial. Definir o seed torna suas simulações reproduzíveis — o mesmo código sempre produz os mesmos resultados, algo essencial para depuração, publicação e ensino.
# 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 o estado do gerador de números aleatórios (RNG). Qualquer inteiro positivo funciona. O seed determina toda a sequência futura de números aleatórios até que o seed seja redefinido. Use um número fixo para garantir a reprodutibilidade.
# 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 do RNG
RNGkind() mostra ou define o algoritmo do RNG. O padrão de R é o Mersenne-Twister, com o método de distribuição normal Inversion. O algoritmo afeta a sequência; portanto, documente tanto o seed quanto o RNGkind para obter reprodutibilidade 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')Inspecionando .Random.seed
.Random.seed é um vetor inteiro global que armazena todo o estado do RNG. Ele é atualizado automaticamente após cada geração de um número aleatório. Você pode salvá-lo e restaurá-lo para reproduzir uma sequência a partir de qualquer ponto.
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)Salvando e restaurando o estado do RNG
Salve o estado do RNG antes de um bloco de código e restaure-o posteriormente para reproduzir exatamente esse bloco. Isso é mais flexível do que set.seed() quando você precisa continuar a partir do meio de uma sequência.
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 paralelo com L'Ecuyer-CMRG
Ao usar computação paralela, cada processo precisa de um fluxo independente de RNG. O gerador L'Ecuyer-CMRG fornece fluxos longos e não sobrepostos para os trabalhadores paralelos, garantindo que os resultados sejam independentes entre os 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')Semente em chamadas de função
Definir uma semente dentro de uma função não afeta o estado de RNG do chamador depois que a função retorna — porque a chamada que define a semente modifica o .Random.seed global. Seja explícito ao gerenciar sementes em funções reutilizáveis.
# 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) # FALSEAmostragem reproduzível
O argumento sample.kind de RNGkind() afeta especificamente sample(). Desde o R 3.6.0, o padrão mudou para 'Rejection' para melhorar a uniformidade — use essa configuração em fluxos de trabalho reproduzíveis.
# 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)Documentando a aleatoriedade
Uma boa prática para pesquisas reproduzíveis é documentar sua versão do R, o valor da semente e RNGkind. Use sessionInfo() para registrar todo o ambiente. Registre as sementes nos comentários do script ou em um arquivo de configuração.
# 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')Sementes em estudos de Monte Carlo
Em estudos de simulação grandes, use uma única semente principal para gerar sementes para cada réplica. Isso torna cada réplica reproduzível individualmente, mantendo o desenho geral determinístico.
# 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]Testando a aleatoriedade com withr
O pacote withr fornece with_seed(seed, expr), que define temporariamente uma semente, avalia a expressão e depois restaura o estado original de RNG — perfeito para testes sem poluir o 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))Verificação rápida
Teste sua compreensão sobre a reprodutibilidade de RNG no R.
Recapitulação: semente e reprodutibilidade
Principais conclusões: set.seed(n) torna o código aleatório reproduzível. RNGkind() mostra ou define o algoritmo — documente tanto a semente quanto o tipo. .Random.seed armazena todo o estado de RNG e pode ser salvo e restaurado. Para computação paralela, use L'Ecuyer-CMRG. Nas funções, aceite um parâmetro seed. Use sementes por réplica geradas a partir de uma semente principal em simulações grandes.
# 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')Perguntas Frequentes
A aula “set.seed() e reprodutibilidade” é grátis?
Sim — o texto completo de “set.seed() e reprodutibilidade” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.
O que vou aprender em “set.seed() e reprodutibilidade”?
Garanta a geração reproduzível de números aleatórios entre as execuções com set.seed(). Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar R Academy?
Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “set.seed() e reprodutibilidade”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de R Academy?
Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- set.seed() e reprodutibilidade
- Geração de distribuições aleatórias
- Fundamentos da simulação de Monte Carlo
- Reamostragem bootstrap em R