R Academy · Ders

R'de Stan Modelleri Yazma

Stan sözdiziminde veri bloklarını, parametreleri ve model bloğunu tanımlayın.

R'de Stan Modelleri Yazma, CoddyKit'te ücretsiz bir R Academy dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, R Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. R Academy kursu toplamda 4 dersten oluşur.

Stan Nedir?

Stan, Bayesçi istatistiksel modelleme için kullanılan olasılıksal bir programlama dilidir. RStan, Stan'in R arayüzüdür. Modeli Stan'in C++ benzeri dilinde yazarsınız; Stan da bunu Hamilton tipi Monte Carlo (HMC) örneklemesini çalıştıran ve sonsal dağılımı yaklaşık hesaplayan verimli C++ koduna derler.

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

Stan Modelinin Yapısı

Bir Stan modeli en fazla altı adlandırılmış blok içerir: data, transformed data, parameters, transformed parameters, model ve generated quantities. Temel üç blok data, parameters ve model bloklarıdır.

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{}: Girdi Verilerini Tanımlama

data bloğu, modelin R'den aldığı tüm dış verileri tanımlar. Türler arasında int, real, vector[N], matrix[M,N] ve array bulunur. <lower=0> gibi kısıtlamalar çalışma zamanında denetlenir.

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{}: Parametre Türleri

parameters bloğu, Stan'ın örnekleyeceği bilinmeyenleri bildirir. Bu bloktaki kısıtlamalar parametre uzayını tanımlar: pozitif nicelikler için <lower=0>, olasılıklar için <lower=0, upper=1>. Stan, kısıtlı parametreler için log-olasılık Jakoben düzeltmelerini otomatik olarak uygular.

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{}: Önsel Dağılımlar ve Olabilirlik

model bloğu, ~ (tilde) sözdizimi aracılığıyla log-artçılı biriktirir. y ~ normal(mu, sigma), Normal PDF'sinin logaritmasını target'a eklemenin kısa yoludur. Açık log-olasılık artışlarını target += normal_lpdf(y | mu, sigma) ile yazabilirsiniz.

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)

Basit Bir Normal Model Uydurma

Burada eksiksiz ve asgari bir Stan iş akışı yer almaktadır: model metnini tanımlayın, veriler listesini hazırlayın, stan() işlevini çağırın ve sonuçları print() ile inceleyin. Stan modeli ilk çalıştırmada derler ve sonraki çalıştırmalar için önbelleğe alır.

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

Stan'de Doğrusal Regresyon

Stan, Bayesçi doğrusal regresyonu kolaylaştırır: katsayılar için normal önsel dağılımlar, sigma içinse üstel veya yarım Cauchy önsel dağılımı belirtin. Artçıl dağılım, yalnızca nokta tahminlerini değil, her katsayı için belirsizliğin tamamını gösteren dağılımı verir.

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

transformed parameters{} Bloğu

transformed parameters bloğu, örneklenen parametrelerden türetilmiş nicelikleri hesaplar. Bunlar, temel parametreleri anlaşılır tutarken modelleri sayısal olarak kararlı bir biçimde parametreleştirmek için kullanışlıdır (ör. Cholesky ayrışımları ve log dönüşümleri).

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

generated quantities{} Bloğu

generated quantities bloğu, ek nicelikleri hesaplamak için örneklemeden sonra çalışır: artçıl öngörü örnekleri (y_rep), LOO-CV için log-olabilirlik veya özetler için dönüştürülmüş parametreler. Buradaki değerler artçıl öngörü dağılımından örneklenir.

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

R'den Stan'e Veri Aktarma

stan() işlevinin data bağımsız değişkeni, adlandırılmış bir R listesidir. Adlar, Stan'in data{} bloğunda bildirilen değişken adlarıyla tam olarak eşleşmelidir. Vektörler Stan'de vector[N] olur; tamsayılar int olur; R matrisleri Stan'de matrix[M,N] olur.

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

Derlenmiş Modeli Görüntüleme

Uydurma işleminden sonra tüm parametreler için artçıl özetleri (ortalama, se_mean, sd, kantiller, Rhat, n_eff) görmek üzere print(fit) kullanın. Görsel bir aralık grafiği için stan_plot(fit), zincirlerin karışmasını değerlendirmek için traceplot(fit) kullanın.

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

Hızlı Kontrol

Bir Stan modelinde, bir parametreyi kesinlikle pozitif olacak şekilde (ör. standart sapma) kısıtlamak istiyorsunuz. Hangi bildirim doğrudur?

Özet: Stan Modelleri Yazma

Temel çıkarımlar:

Stan modelinin üç temel bloğu vardır: data{}, parameters{}, model{}
Kısıtlamalar: olasılıklar için <lower=0>, <upper=1>, <lower=0, upper=1>
Türler: int, real, vector[N], matrix[M,N], simplex[K]
Model bloğu: önsel dağılımlar ve olabilirlik için tilde sözdizimini, yani y ~ normal(mu, sigma) ifadesini kullanın
Türetilmiş nicelikler için transformed parameters{}; örnekleme sonrası işlemler için generated quantities{}
Verileri, Stan blok adlarıyla tam olarak eşleşen adlandırılmış bir R listesi olarak aktarın
rstan_options(auto_write = TRUE) derlenmiş modelleri önbelleğe alır

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

Sıkça Sorulan Sorular

“R'de Stan Modelleri Yazma” dersi ücretsiz mi?

Evet — “R'de Stan Modelleri Yazma” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve R Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. R Academy kursu toplamda 4 dersten oluşur.

“R'de Stan Modelleri Yazma” dersinde ne öğreneceğim?

Stan sözdiziminde veri bloklarını, parametreleri ve model bloğunu tanımlayın. R Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

R Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te R Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“R'de Stan Modelleri Yazma” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu R Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her R Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← R Academy Sayfasına Dön