R Academy · Lektion

Skriv Stan-modeller i R

Definér datablokke, parametre og modelblokken i Stan-syntaks.

Lektion 2 af 413 trin

Skriv Stan-modeller i R er en gratis R Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i R Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. R Academy-kurset indeholder 4 lektioner i alt.

Hvad er Stan?

Stan er et sandsynlighedsbaseret programmeringssprog til Bayesiansk statistisk modellering. RStan er R-grænsefladen til Stan. Du skriver modellen i Stans sprog (C++-lignende), og Stan kompilerer den til effektiv C++-kode, der udfører Hamiltonian Monte Carlo-sampling (HMC) for at approksimere den efterfølgende fordeling.

# Stan installation check
library(rstan)

# Check version
cat('RStan version:', as.character(packageVersion('rstan')), '\n')

# Enable parallel chains
options(mc.cores = parallel::detectCores())

# Reuse compiled models across sessions
rstan_options(auto_write = TRUE)

cat('Stan ready. Cores:', parallel::detectCores(), '\n')

Strukturen i en Stan-model

En Stan-model har op til seks navngivne blokke: data, transformed data, parameters, transformed parameters, model og generated quantities. De tre nødvendige blokke er data, parameters og model.

library(rstan)

# Stan model as a character string in R
stan_code <- '
data {
  int<lower=0> N;       // number of observations
  vector[N] x;          // predictor
  vector[N] y;          // response
}
parameters {
  real alpha;           // intercept
  real beta;            // slope
  real<lower=0> sigma;  // noise (must be positive)
}
model {
  // Priors
  alpha ~ normal(0, 10);
  beta  ~ normal(0, 10);
  sigma ~ exponential(1);

  // Likelihood
  y ~ normal(alpha + beta * x, sigma);
}
'

cat('Stan model defined as a string in R\n')
cat('Blocks: data, parameters, model\n')

data{}: Erklæring af inputdata

Blokken data erklærer alle eksterne data, som modellen modtager fra R. Typer omfatter int, real, vector[N], matrix[M,N] og array. Begrænsninger som <lower=0> kontrolleres under kørsel.

library(rstan)

# Comprehensive data block examples
data_block_examples <- '
data {
  // Scalars
  int<lower=1> N;               // at least 1 observation
  int<lower=2> K;               // at least 2 groups

  // Constrained scalars
  real<lower=0, upper=1> rate;  // probability

  // Vectors
  vector[N] y;                  // continuous response
  array[N] int<lower=0, upper=1> z;  // binary outcomes

  // Matrix
  matrix[N, K] X;               // design matrix

  // Integer array
  array[N] int group;           // group membership 1..K
}
'

cat(data_block_examples)

parameters{}: Parametertyper

Blokken parameters erklærer de ukendte størrelser, som Stan skal udtage stikprøver af. Begrænsningerne i denne blok definerer parameterrummet: <lower=0> for positive størrelser og <lower=0, upper=1> for sandsynligheder. Stan anvender automatisk Jacobian-korrektioner for log-sandsynligheden på parametre med begrænsninger.

library(rstan)

# Common parameter declarations
param_examples <- '
parameters {
  // Unconstrained
  real mu;                        // mean
  vector[K] beta;                 // regression coefficients

  // Positive (sigma, lambda, variance)
  real<lower=0> sigma;
  real<lower=0> lambda;

  // Probability
  real<lower=0, upper=1> theta;

  // Simplex (sums to 1, for mixture weights)
  simplex[K] pi;

  // Correlation matrix
  corr_matrix[K] Omega;

  // Cholesky factor of covariance
  cholesky_factor_cov[K] L_Sigma;
}
'
cat(param_examples)

model{}: Forudgående fordelinger og likelihood

Blokken model akkumulerer log-posterioren ved hjælp af syntaksen med ~ (tilde). y ~ normal(mu, sigma) er en forkortelse for at føje logaritmen af den normale tæthedsfunktion til target. Du kan skrive eksplicitte inkrementer til log-sandsynligheden med target += normal_lpdf(y | mu, sigma).

library(rstan)

model_block_example <- '
model {
  // --- Priors ---
  mu    ~ normal(0, 10);          // weakly informative
  sigma ~ cauchy(0, 2.5);         // half-Cauchy for scale
  beta  ~ normal(0, 1);           // standardised coefficients

  // --- Likelihood ---
  // Tilde notation (most common)
  y ~ normal(mu + X * beta, sigma);

  // Equivalent explicit notation:
  // target += normal_lpdf(y | mu + X * beta, sigma);

  // For loop (less common but valid)
  // for (i in 1:N)
  //   target += normal_lpdf(y[i] | mu, sigma);
}
'
cat(model_block_example)

Tilpasning af en simpel normalmodel

Her er en komplet, minimal Stan-arbejdsgang: definér modelstrengen, klargør datalisten, kald stan(), og undersøg resultaterne med print(). Stan kompilerer modellen første gang og gemmer den til efterfølgende kørsler.

library(rstan)

# Stan model: estimate mean and SD of a normal distribution
normal_model <- '
data {
  int<lower=0> N;
  vector[N] y;
}
parameters {
  real mu;
  real<lower=0> sigma;
}
model {
  mu    ~ normal(0, 10);
  sigma ~ exponential(0.1);
  y     ~ normal(mu, sigma);
}
'

# Simulate data
set.seed(42)
y_data <- rnorm(50, mean = 5, sd = 2)

# Fit the model
fit <- stan(
  model_code = normal_model,
  data       = list(N = length(y_data), y = y_data),
  chains     = 2,
  iter       = 1000,
  warmup     = 500,
  refresh    = 0  # suppress iteration output
)

print(fit, pars = c('mu', 'sigma'))

Lineær regression i Stan

Stan gør Bayesiansk lineær regression enkel: angiv normale forudgående fordelinger for koefficienterne og en eksponentiel eller halv-Cauchy-fordeling for sigma. Posteriorfordelingen giver den fulde usikkerhedsfordeling for hver koefficient, ikke kun punktestimater.

library(rstan)

lin_reg_model <- '
data {
  int<lower=0> N;
  vector[N] x;
  vector[N] y;
}
parameters {
  real alpha;
  real beta;
  real<lower=0> sigma;
}
model {
  alpha ~ normal(0, 10);
  beta  ~ normal(0, 10);
  sigma ~ exponential(1);
  y ~ normal(alpha + beta * x, sigma);
}
generated quantities {
  vector[N] y_rep;  // posterior predictive
  for (i in 1:N)
    y_rep[i] = normal_rng(alpha + beta * x[i], sigma);
}
'

set.seed(7)
n <- 80
x <- rnorm(n); y <- 2 + 3 * x + rnorm(n, 0, 1)

fit <- stan(model_code = lin_reg_model,
            data = list(N = n, x = x, y = y),
            chains = 2, iter = 1000, refresh = 0)
print(fit, pars = c('alpha', 'beta', 'sigma'))

Blokken transformed parameters{}

Blokken transformed parameters beregner afledte størrelser ud fra de udtagne parametre. De er nyttige til at parametrisationere modeller numerisk stabilt, f.eks. med Cholesky-dekompositioner og logaritmetransformationer, samtidig med at de primære parametre forbliver fortolkelige.

library(rstan)

# Model with transformed parameters
trans_param_example <- '
data {
  int<lower=0> N;
  array[N] int<lower=0> y;  // counts
}
parameters {
  real log_lambda;           // work in log space for stability
}
transformed parameters {
  real<lower=0> lambda;
  lambda = exp(log_lambda);  // transform back to original scale
}
model {
  log_lambda ~ normal(1, 2);  // prior on log scale
  y ~ poisson(lambda);
}
'

set.seed(42)
y_counts <- rpois(30, lambda = 5)

fit_poisson <- stan(
  model_code = trans_param_example,
  data       = list(N = length(y_counts), y = y_counts),
  chains     = 2, iter = 1000, refresh = 0
)
print(fit_poisson, pars = c('log_lambda', 'lambda'))

Blokken generated quantities{}

Blokken generated quantities køres efter stikprøveudtagningen for at beregne yderligere størrelser: posterior-prediktive stikprøver (y_rep), log-likelihood til LOO-CV eller transformerede parametre til opsummeringer. Værdierne her udtages fra den posterior-prediktive fordeling.

library(rstan)

# Use generated quantities for posterior predictive checks
model_with_gq <- '
data {
  int<lower=0> N;
  vector[N] y;
}
parameters {
  real mu;
  real<lower=0> sigma;
}
model {
  mu    ~ normal(0, 10);
  sigma ~ exponential(0.5);
  y     ~ normal(mu, sigma);
}
generated quantities {
  vector[N] y_rep;           // replicated datasets
  real mean_y_rep;           // mean of replicated data
  for (i in 1:N)
    y_rep[i] = normal_rng(mu, sigma);
  mean_y_rep = mean(y_rep);
}
'

set.seed(1)
y_obs <- rnorm(40, 3, 1.5)
fit <- stan(model_code = model_with_gq,
            data = list(N = length(y_obs), y = y_obs),
            chains = 2, iter = 1000, refresh = 0)
print(fit, pars = c('mu', 'sigma', 'mean_y_rep'))

Overførsel af data fra R til Stan

Argumentet data til stan() er en navngivet R-liste. Navnene skal stemme nøjagtigt overens med variabelnavnene, der er erklæret i Stans data{}-blok. Vektorer bliver til Stan-typen vector[N], heltal bliver til int, og R-matricer bliver til Stan-typen matrix[M,N].

library(rstan)

# Data preparation: names must match Stan data block exactly
set.seed(42)
n <- 60
x1 <- rnorm(n)
x2 <- rnorm(n)
y  <- 1.5 + 2 * x1 - 0.8 * x2 + rnorm(n, 0, 0.5)

# Build the design matrix
X <- cbind(x1, x2)  # 60 x 2 matrix

# Named list passed to stan(data = ...)
stan_data <- list(
  N = n,          # int
  K = ncol(X),    # int
  X = X,          # matrix[N, K]
  y = y           # vector[N]
)

cat('Stan data list elements:\n')
for (nm in names(stan_data)) {
  cat(' ', nm, ': class =', class(stan_data[[nm]]),
      'dim =', paste(dim(stan_data[[nm]]), collapse = 'x'),
      '\n')
}

Visning af den kompilerede model

Efter tilpasningen kan du bruge print(fit) til at se posterior-opsummeringer (middelværdi, se_mean, sd, kvantiler, Rhat, n_eff) for alle parametre. Brug stan_plot(fit) til et visuelt intervaldiagram og traceplot(fit) til at vurdere blandingen af kæderne.

library(rstan)

# Reuse the simple normal model from scene 6
normal_model <- '
data { int<lower=0> N; vector[N] y; }
parameters { real mu; real<lower=0> sigma; }
model {
  mu ~ normal(0, 10);
  sigma ~ exponential(0.1);
  y ~ normal(mu, sigma);
}
'

set.seed(5)
fit <- stan(model_code = normal_model,
            data = list(N = 50, y = rnorm(50, 7, 3)),
            chains = 2, iter = 1000, refresh = 0)

# Detailed summary table
print(fit)

# Extract as data frame
posterior_df <- as.data.frame(fit)
cat('\nPosterior samples shape:', nrow(posterior_df),
    'rows x', ncol(posterior_df), 'cols\n')

Hurtigt tjek

I en Stan-model vil du begrænse en parameter til at være strengt positiv, f.eks. en standardafvigelse. Hvilken erklæring er korrekt?

Besvar den i den interaktive lektion

Opsummering: Skrivning af Stan-modeller

Vigtigste pointer:

En Stan-model har tre vigtige blokke: data{}, parameters{}, model{}
Begrænsninger: <lower=0>, <upper=1>, <lower=0, upper=1> for sandsynligheder
Typer: int, real, vector[N], matrix[M,N], simplex[K]
Modelblok: brug tilde-syntaksen y ~ normal(mu, sigma) til forudgående fordelinger og likelihood
transformed parameters{} til afledte størrelser; generated quantities{} til beregninger efter stikprøveudtagningen
Overfør data som en navngivet R-liste, hvis navne stemmer nøjagtigt overens med Stan-blokkenes navne
rstan_options(auto_write = TRUE) gemmer kompilerede modeller

library(rstan)

# Stan model skeleton
model_skeleton <- '
data    { int N; vector[N] y; }
parameters { real mu; real<lower=0> sigma; }
model   { mu ~ normal(0,10); sigma ~ exponential(1); y ~ normal(mu, sigma); }
'
cat(model_skeleton)
cat('\nFit with: stan(model_code = model_skeleton, data = list(N=..., y=...), chains=4)\n')

Gratis at komme i gang

Lær R med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 43
Lektioner: 159

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Skriv Stan-modeller i R” gratis?

Ja — alle 3 lektioner i læringssporet R Academy, inklusive “Skriv Stan-modeller i R”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. R Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Skriv Stan-modeller i R”?

Definér datablokke, parametre og modelblokken i Stan-syntaks. Du øver dig i R Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på R Academy?

Der kræves ingen tidligere erfaring. R Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Skriv Stan-modeller i R”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne R Academy-lektion?

Ja. Alle R Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til R Academy