R Academy · Lektion

Stan-Modelle in R schreiben

Definieren Sie Datenblöcke, Parameter und den Modellblock in der Stan-Syntax

Lektion 2 von 413 Schritte

Stan-Modelle in R schreiben ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Stan?

Stan ist eine probabilistische Programmiersprache für bayessche statistische Modellierung. RStan ist die R-Schnittstelle zu Stan. Sie schreiben das Modell in der Sprache von Stan (ähnlich wie C++), und Stan kompiliert es in effizienten C++-Code, der Hamiltonian Monte Carlo (HMC) verwendet, um die Posteriorverteilung anzunähern.

# 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')

Struktur eines Stan-Modells

Ein Stan-Modell kann bis zu sechs benannte Blöcke enthalten: data, transformed data, parameters, transformed parameters, model und generated quantities. Die drei wesentlichen Blöcke sind data, parameters und 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{}: Eingabedaten deklarieren

Der data-Block deklariert alle externen Daten, die das Modell aus R erhält. Zu den Datentypen gehören int, real, vector[N], matrix[M,N] und array. Einschränkungen wie <lower=0> werden zur Laufzeit überprüft.

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{}: Parametertypen

Der parameters-Block deklariert die unbekannten Größen, aus denen Stan Stichproben zieht. Einschränkungen in diesem Block definieren den Parameterraum: <lower=0> für positive Größen, <lower=0, upper=1> für Wahrscheinlichkeiten. Stan wendet für eingeschränkte Parameter automatisch Jacobian-Korrekturen der Log-Wahrscheinlichkeit an.

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{}: Priors und Likelihood

Der model-Block akkumuliert die Log-Posterior-Wahrscheinlichkeit mithilfe der ~-Syntax (Tilde-Syntax). y ~ normal(mu, sigma) ist eine Kurzform dafür, den Logarithmus der Normaldichte zu target hinzuzufügen. Explizite Inkremente der Log-Wahrscheinlichkeit können Sie mit target += normal_lpdf(y | mu, sigma) schreiben.

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)

Anpassen eines einfachen Normalmodells

Hier ist ein vollständiger, minimaler Stan-Workflow: Definieren Sie den Modell-String, bereiten Sie die Datenliste vor, rufen Sie stan() auf und untersuchen Sie die Ergebnisse mit print(). Stan kompiliert das Modell beim ersten Aufruf und speichert es für nachfolgende Durchläufe im Cache.

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'))

Lineare Regression in Stan

Mit Stan lässt sich eine bayesianische lineare Regression unkompliziert umsetzen: Geben Sie Normalverteilungen als Priors für die Koeffizienten und einen exponentiellen oder Half-Cauchy-Prior für sigma an. Die Posterior-Verteilung liefert für jeden Koeffizienten die vollständige Unsicherheitsverteilung und nicht nur Punktschätzungen.

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'))

Block transformed parameters{}

Der transformed parameters-Block berechnet abgeleitete Größen aus den Stichproben der Parameter. Diese Größen sind nützlich, um Modelle numerisch stabil zu parametrisieren (z. B. durch Cholesky-Zerlegungen oder Logarithmustransformationen) und gleichzeitig die primären Parameter interpretierbar zu halten.

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'))

Block generated quantities{}

Der generated quantities-Block wird nach dem Sampling ausgeführt, um zusätzliche Größen zu berechnen: posterior-prädiktive Stichproben (y_rep), die Log-Likelihood für LOO-CV oder transformierte Parameter für Zusammenfassungen. Die Werte in diesem Block werden aus der posterior-prädiktiven Verteilung gezogen.

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'))

Daten von R an Stan übergeben

Das Argument data von stan() ist eine benannte R-Liste. Die Namen müssen exakt mit den Variablennamen übereinstimmen, die im Stan-Block data{} deklariert sind. Vektoren werden zu Stan-vector[N], Ganzzahlen zu int und R-Matrizen zu Stan-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')
}

Das kompilierte Modell anzeigen

Verwenden Sie nach dem Anpassen print(fit), um für alle Parameter Posterior-Zusammenfassungen (mean, se_mean, sd, Quantile, Rhat, n_eff) anzuzeigen. Mit stan_plot(fit) erhalten Sie ein grafisches Intervall-Diagramm und mit traceplot(fit) können Sie die Durchmischung der Ketten beurteilen.

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')

Schnelltest

In einem Stan-Modell soll ein Parameter strikt positiv sein (z. B. eine Standardabweichung). Welche Deklaration ist korrekt?

Beantworte es in der interaktiven Lektion

Zusammenfassung: Stan-Modelle schreiben

Wichtige Erkenntnisse:

Ein Stan-Modell hat drei wesentliche Blöcke: data{}, parameters{}, model{}
Einschränkungen: <lower=0>, <upper=1>, <lower=0, upper=1> für Wahrscheinlichkeiten
Typen: int, real, vector[N], matrix[M,N], simplex[K]
Model-Block: Verwenden Sie die Tilde-Syntax y ~ normal(mu, sigma) für Priors und Likelihood
transformed parameters{} für abgeleitete Größen; generated quantities{} für die Zeit nach dem Sampling
Übergeben Sie die Daten als benannte R-Liste, deren Namen exakt mit den Stan-Blocknamen übereinstimmen
rstan_options(auto_write = TRUE) speichert kompilierte Modelle im Cache

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')

Kostenlos starten

Lerne R mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 43
Lektionen: 159

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Stan-Modelle in R schreiben“ kostenlos?

Ja — der vollständige Text von „Stan-Modelle in R schreiben“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Stan-Modelle in R schreiben“?

Definieren Sie Datenblöcke, Parameter und den Modellblock in der Stan-Syntax Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um R Academy zu starten?

Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Stan-Modelle in R schreiben“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?

Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu R Academy