Lineer Karışık Efekt Modelleri

TensorFlow.org'da görüntüleyin

Google Colab'da çalıştırın

Kaynağı GitHub'da görüntüleyin

Not defterini indir

Doğrusal karma etkiler modeli, yapılandırılmış doğrusal ilişkileri modellemek için basit bir yaklaşımdır (Harville, 1997; Laird ve Ware, 1982). Her veri noktası, gruplara ayrılmış, farklı türde girdilerden ve gerçek değerli bir çıktıdan oluşur. Bir karışık doğrusal etki modeli hiyerarşik bir modeldir: Herhangi bir tek veri noktası ile ilgili çıkarımlarda geliştirmek için gruplar arasında istatistiksel gücü paylaşır.

Bu öğreticide, TensorFlow Probability'de gerçek dünyadan bir örnekle doğrusal karışık efekt modellerini gösteriyoruz. Biz JointDistributionCoroutine ve Markov Zincir Monte Carlo (kullanacağız tfp.mcmc ) modülleri.

Bağımlılıklar ve Ön Koşullar

İthalat ve kurulumlar

import csv
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import requests

import tensorflow.compat.v2 as tf
tf.enable_v2_behavior()

import tensorflow_probability as tfp

tfd = tfp.distributions
tfb = tfp.bijectors

dtype = tf.float64

%config InlineBackend.figure_format = 'retina'
%matplotlib inline
plt.style.use('ggplot')

İşleri Hızlandırın!

Dalmadan önce, bu demo için bir GPU kullandığımızdan emin olalım.

Bunu yapmak için "Çalışma Zamanı" -> "Çalışma zamanı türünü değiştir" -> "Donanım hızlandırıcı" -> "GPU" öğesini seçin.

Aşağıdaki kod parçası, bir GPU'ya erişimimiz olduğunu doğrulayacaktır.

if tf.test.gpu_device_name() != '/device:GPU:0':
  print('WARNING: GPU device not found.')
else:
  print('SUCCESS: Found GPU: {}'.format(tf.test.gpu_device_name()))

SUCCESS: Found GPU: /device:GPU:0

Veri

Kullandığımız InstEval popüler veri setini lme4 R paketin (Bates ve arkadaşları., 2015). Derslerin ve bunların değerlendirme puanlarının bir veri setidir. Her ders gibi meta içeren students , instructors ve departments ve ilgi yanıt değişkeni değerlendirme derecedir.

def load_insteval():
  """Loads the InstEval data set.

  It contains 73,421 university lecture evaluations by students at ETH
  Zurich with a total of 2,972 students, 2,160 professors and
  lecturers, and several student, lecture, and lecturer attributes.
  Implementation is built from the `observations` Python package.

  Returns:
    Tuple of np.ndarray `x_train` with 73,421 rows and 7 columns and
    dictionary `metadata` of column headers (feature names).
  """
  url = ('https://raw.github.com/vincentarelbundock/Rdatasets/master/csv/'
         'lme4/InstEval.csv')
  with requests.Session() as s:
    download = s.get(url)
    f = download.content.decode().splitlines()

  iterator = csv.reader(f)
  columns = next(iterator)[1:]
  x_train = np.array([row[1:] for row in iterator], dtype=np.int)
  metadata = {'columns': columns}
  return x_train, metadata

Veri setini yüklüyor ve ön işliyoruz. Uydurma modelimizi görünmeyen veri noktalarında değerlendirebilmek için verilerin %20'sini elimizde tutuyoruz. Aşağıda ilk birkaç satırı görselleştiriyoruz.

data, metadata = load_insteval()
data = pd.DataFrame(data, columns=metadata['columns'])
data = data.rename(columns={'s': 'students',
                            'd': 'instructors',
                            'dept': 'departments',
                            'y': 'ratings'})
data['students'] -= 1  # start index by 0
# Remap categories to start from 0 and end at max(category).
data['instructors'] = data['instructors'].astype('category').cat.codes
data['departments'] = data['departments'].astype('category').cat.codes

train = data.sample(frac=0.8)
test = data.drop(train.index)

train.head()

Biz açısından veri kümesini kurmak features girdilerin sözlüğe ve labels çıkışı değerlendirmesi karşılık gelir. Her özellik bir tamsayı olarak kodlanmıştır ve her etiket (değerlendirme derecesi) bir kayan noktalı sayı olarak kodlanmıştır.

get_value = lambda dataframe, key, dtype: dataframe[key].values.astype(dtype)
features_train = {
    k: get_value(train, key=k, dtype=np.int32)
    for k in ['students', 'instructors', 'departments', 'service']}
labels_train = get_value(train, key='ratings', dtype=np.float32)

features_test = {k: get_value(test, key=k, dtype=np.int32)
                 for k in ['students', 'instructors', 'departments', 'service']}
labels_test = get_value(test, key='ratings', dtype=np.float32)

num_students = max(features_train['students']) + 1
num_instructors = max(features_train['instructors']) + 1
num_departments = max(features_train['departments']) + 1
num_observations = train.shape[0]

print("Number of students:", num_students)
print("Number of instructors:", num_instructors)
print("Number of departments:", num_departments)
print("Number of observations:", num_observations)

Number of students: 2972
Number of instructors: 1128
Number of departments: 14
Number of observations: 58737

modeli

Tipik bir doğrusal model, herhangi bir veri noktası çiftinin sabit bir doğrusal ilişkiye sahip olduğu bağımsızlığı varsayar. Gelen InstEval veri seti, gözlemler değişen eğimleri ve yakaladığını sahip olabilen gruplar halinde ortaya çıkar. Hiyerarşik lineer modeller veya çok seviyeli lineer modeller olarak da bilinen lineer karma efekt modelleri, bu fenomeni yakalar (Gelman & Hill, 2006).

Bu fenomenin örnekleri şunları içerir:

• Öğrencileri. Bir öğrencinin gözlemleri bağımsız değildir: bazı öğrenciler sistematik olarak düşük (veya yüksek) ders notları verebilir.
• Eğitmenler. Bir eğitmenin gözlemleri bağımsız değildir: iyi öğretmenlerin genel olarak iyi notlar almasını ve kötü öğretmenlerin genellikle kötü notlar almasını bekleriz.
• Bölümler. Bir bölümden elde edilen gözlemler bağımsız değildir: belirli bölümler genellikle kuru malzemeye veya daha katı derecelendirmeye sahip olabilir ve bu nedenle diğerlerinden daha düşük derecelendirilmiş olabilir.

Bu, bir veri kümesi için bu hatırlama yakalamak için \(N\times D\) özellikleri \(\mathbf{X}\) ve \(N\) etiketleri \(\mathbf{y}\)modeli, lineer regresyon konumlandırdığı

\[ \begin{equation*} \mathbf{y} = \mathbf{X}\beta + \alpha + \epsilon, \end{equation*} \]

bir eğim vektörü olduğu yerde \(\beta\in\mathbb{R}^D\), kesişme \(\alpha\in\mathbb{R}\)ve rasgele gürültü \(\epsilon\sim\text{Normal}(\mathbf{0}, \mathbf{I})\). Biz söylemek \(\beta\) ve \(\alpha\) "sabit etkiler": onlar veri noktalarının nüfus karşısında sabit tutulan etkilerdir \((x, y)\). Bir olasılığı olarak denklemin eşdeğer formülasyondur \(\mathbf{y} \sim \text{Normal}(\mathbf{X}\beta + \alpha, \mathbf{I})\). Bu olasılık olduğunu hesaplamıştır bulmak için çıkarsama sırasında ekranı kaplamış \(\beta\) ve \(\alpha\) verilerini uygun.

Doğrusal bir karma etkiler modeli, doğrusal regresyonu şu şekilde genişletir:

\[ \begin{align*} \eta &\sim \text{Normal}(\mathbf{0}, \sigma^2 \mathbf{I}), \\ \mathbf{y} &= \mathbf{X}\beta + \mathbf{Z}\eta + \alpha + \epsilon. \end{align*} \]

Hala bir eğim vektörü olduğu yerde \(\beta\in\mathbb{R}^P\), kesişme \(\alpha\in\mathbb{R}\)ve rasgele gürültü \(\epsilon\sim\text{Normal}(\mathbf{0}, \mathbf{I})\). Buna ek olarak, bir terim olduğu \(\mathbf{Z}\eta\), \(\mathbf{Z}\) bir özellik matrisi ve bir \(\eta\in\mathbb{R}^Q\) rasgele yamaçları bir vektördür; \(\eta\) normal varyans bileşeni parametresi ile dağıtılan \(\sigma^2\). \(\mathbf{Z}\) orijinal bölünmesi oluşur \(N\times D\) yeni bakımından matriks özellikleri \(N\times P\) matris \(\mathbf{X}\) ve \(N\times Q\) matris \(\mathbf{Z}\), \(P + Q=D\)bu bölüm bize kullanarak ayrı ayrı özellikleri modellemek sağlar: sabit etkiler \(\beta\) ve latent değişken \(\eta\) sırasıyla.

Biz gizli değişkenler demek \(\eta\) "rasgele etkiler": onlar (onlar subpopulations genelinde sabiti olabilir rağmen) nüfus arasında farklılık etkileridir. Rastgele etkiler çünkü Özellikle, \(\eta\) veri etiketin ortalama tarafından yakalanır, ortalama 0 var \(\mathbf{X}\beta + \alpha\). Rastgele etkili bileşen \(\mathbf{Z}\eta\) veri yakalar varyasyon: "54 daha yüksek ortalama 1,4 puan derecelendirilmiştir # Öğretim", örneğin,

Bu eğitimde, aşağıdaki etkileri yerleştiriyoruz:

• Sabit etkiler: service . service dersi veren öğretim üyesinin ana bölüme ait olup olmadığını karşılık gelen bir ikili eşdeğişken olduğunu. Topladığımız ne kadar ek veri olursa olsun, sadece değerler alabilir \(0\) ve \(1\).
• Rastgele etkiler: students , instructors ve departments . Kurs değerlendirme derecelendirme popülasyonundan daha fazla gözlem verildiğinde, yeni öğrencilere, öğretmenlere veya bölümlere bakıyor olabiliriz.

R's lme4 paketinin sözdiziminde (Bates ve diğerleri, 2015), model şu şekilde özetlenebilir:

ratings ~ service + (1|students) + (1|instructors) + (1|departments) + 1

burada x , sabit bir etki gösterir (1|x) için rasgele bir etki gösterir x ve 1 bir sabit terim anlamına gelmektedir.

Bu modeli aşağıda JointDistribution olarak uyguluyoruz. Parametre takibi için daha iyi destek sağlamak için (örneğin, hepimiz izlemek istediğiniz tf.Variable içinde model.trainable_variables , biz modeli şablonunu uygulamak) tf.Module .

class LinearMixedEffectModel(tf.Module):
  def __init__(self):
    # Set up fixed effects and other parameters.
    # These are free parameters to be optimized in E-steps
    self._intercept = tf.Variable(0., name="intercept")            # alpha in eq
    self._effect_service = tf.Variable(0., name="effect_service")  #  beta in eq
    self._stddev_students = tfp.util.TransformedVariable(
        1., bijector=tfb.Exp(), name="stddev_students")            # sigma in eq
    self._stddev_instructors = tfp.util.TransformedVariable(
        1., bijector=tfb.Exp(), name="stddev_instructors")         # sigma in eq
    self._stddev_departments = tfp.util.TransformedVariable(
        1., bijector=tfb.Exp(), name="stddev_departments")         # sigma in eq

  def __call__(self, features):
    model = tfd.JointDistributionSequential([
      # Set up random effects.
      tfd.MultivariateNormalDiag(
          loc=tf.zeros(num_students),
          scale_identity_multiplier=self._stddev_students),
      tfd.MultivariateNormalDiag(
          loc=tf.zeros(num_instructors),
          scale_identity_multiplier=self._stddev_instructors),
      tfd.MultivariateNormalDiag(
          loc=tf.zeros(num_departments),
          scale_identity_multiplier=self._stddev_departments),
      # This is the likelihood for the observed.
      lambda effect_departments, effect_instructors, effect_students: tfd.Independent(
          tfd.Normal(
              loc=(self._effect_service * features["service"] +
                  tf.gather(effect_students, features["students"], axis=-1) +
                  tf.gather(effect_instructors, features["instructors"], axis=-1) +
                  tf.gather(effect_departments, features["departments"], axis=-1) +
                  self._intercept),
              scale=1.),
              reinterpreted_batch_ndims=1)
    ])

    # To enable tracking of the trainable variables via the created distribution,
    # we attach a reference to `self`. Since all TFP objects sub-class
    # `tf.Module`, this means that the following is possible:
    # LinearMixedEffectModel()(features_train).trainable_variables
    # ==> tuple of all tf.Variables created by LinearMixedEffectModel.
    model._to_track = self
    return model

lmm_jointdist = LinearMixedEffectModel()
# Conditioned on feature/predictors from the training data
lmm_train = lmm_jointdist(features_train)

lmm_train.trainable_variables

(<tf.Variable 'stddev_students:0' shape=() dtype=float32, numpy=0.0>,
 <tf.Variable 'stddev_instructors:0' shape=() dtype=float32, numpy=0.0>,
 <tf.Variable 'stddev_departments:0' shape=() dtype=float32, numpy=0.0>,
 <tf.Variable 'effect_service:0' shape=() dtype=float32, numpy=0.0>,
 <tf.Variable 'intercept:0' shape=() dtype=float32, numpy=0.0>)

Olasılıksal bir grafik programı olarak, modelin yapısını hesaplama grafiği açısından da görselleştirebiliriz. Bu grafik, programdaki rastgele değişkenler arasındaki veri akışını kodlayarak, bunların ilişkilerini bir grafik model açısından açık hale getirir (Jordan, 2003).

İstatistiksel bir araç olarak, örneğin, daha iyi görebilmek için grafiğe o görünebilir intercept ve effect_service şartlı bağımlı verilen vardır ratings ; Eğer program sınıflar, modüller arası çapraz referanslar ve/veya alt programlar ile yazılmışsa bunu kaynak koddan görmek daha zor olabilir. Bir hesaplama aracı olarak, biz de gizli değişkenler akar fark edebilirsiniz ratings yoluyla değişken tf.gather op. İndeksleme, bu belirli bir donanım hızlandırıcı bir darboğaz olabilir Tensor s pahalıdır; grafiği görselleştirmek, bunu kolayca ortaya çıkarır.

lmm_train.resolve_graph()

(('effect_students', ()),
 ('effect_instructors', ()),
 ('effect_departments', ()),
 ('x', ('effect_departments', 'effect_instructors', 'effect_students')))

Parametre Tahmini

Veri alındığında, çıkarsama amacı modelin sabit etkiler yamaç sığdırmak için \(\beta\), kesişme \(\alpha\)ve varyans bileşeni parametre \(\sigma^2\). Maksimum olabilirlik ilkesi bu görevi şu şekilde resmileştirir:

\[ \max_{\beta, \alpha, \sigma}~\log p(\mathbf{y}\mid \mathbf{X}, \mathbf{Z}; \beta, \alpha, \sigma) = \max_{\beta, \alpha, \sigma}~\log \int p(\eta; \sigma) ~p(\mathbf{y}\mid \mathbf{X}, \mathbf{Z}, \eta; \beta, \alpha)~d\eta. \]

Bu öğreticide, bu marjinal yoğunluğu maksimize etmek için Monte Carlo EM algoritmasını kullanıyoruz (Dempster ve diğerleri, 1977; Wei ve Tanner, 1990).¹ rastgele etkiler ("E-adım") ve parametrelere ("M-adım") göre beklentiyi en üst düzeye çıkarmak için gradyan inişi gerçekleştiririz:

• E-adım için Hamiltonian Monte Carlo'yu (HMC) kurduk. Geçerli bir durumu (öğrenci, eğitmen ve bölüm etkileri) alır ve yeni bir durum döndürür. Yeni durumu, HMC zincirinin durumunu gösterecek olan TensorFlow değişkenlerine atarız.

• M adımı için, bir sabite kadar marjinal olasılığın tarafsız bir tahminini hesaplamak için HMC'den gelen arka örneği kullanırız. Daha sonra gradyanını ilgilenilen parametrelere göre uygularız. Bu, marjinal olabilirlik üzerinde tarafsız bir stokastik iniş adımı üretir. Adam TensorFlow optimizer ile uyguluyoruz ve marjinalin negatifini en aza indiriyoruz.

target_log_prob_fn = lambda *x: lmm_train.log_prob(x + (labels_train,))
trainable_variables = lmm_train.trainable_variables
current_state = lmm_train.sample()[:-1]

# For debugging
target_log_prob_fn(*current_state)

<tf.Tensor: shape=(), dtype=float32, numpy=-528062.5>

# Set up E-step (MCMC).
hmc = tfp.mcmc.HamiltonianMonteCarlo(
    target_log_prob_fn=target_log_prob_fn,
    step_size=0.015,
    num_leapfrog_steps=3)
kernel_results = hmc.bootstrap_results(current_state)

@tf.function(autograph=False, jit_compile=True)
def one_e_step(current_state, kernel_results):
  next_state, next_kernel_results = hmc.one_step(
      current_state=current_state,
      previous_kernel_results=kernel_results)
  return next_state, next_kernel_results

optimizer = tf.optimizers.Adam(learning_rate=.01)

# Set up M-step (gradient descent).
@tf.function(autograph=False, jit_compile=True)
def one_m_step(current_state):
  with tf.GradientTape() as tape:
    loss = -target_log_prob_fn(*current_state)
  grads = tape.gradient(loss, trainable_variables)
  optimizer.apply_gradients(zip(grads, trainable_variables))
  return loss

Eğitimin posteriorun olasılık kütlesi içinde başlatılabilmesi için bir dizi yineleme için bir MCMC zinciri çalıştıran bir ısınma aşaması gerçekleştiriyoruz. Daha sonra bir eğitim döngüsü çalıştırıyoruz. E ve M adımlarını birlikte çalıştırır ve eğitim sırasında değerleri kaydeder.

num_warmup_iters = 1000
num_iters = 1500
num_accepted = 0
effect_students_samples = np.zeros([num_iters, num_students])
effect_instructors_samples = np.zeros([num_iters, num_instructors])
effect_departments_samples = np.zeros([num_iters, num_departments])
loss_history = np.zeros([num_iters])

# Run warm-up stage.
for t in range(num_warmup_iters):
  current_state, kernel_results = one_e_step(current_state, kernel_results)
  num_accepted += kernel_results.is_accepted.numpy()
  if t % 500 == 0 or t == num_warmup_iters - 1:
    print("Warm-Up Iteration: {:>3} Acceptance Rate: {:.3f}".format(
        t, num_accepted / (t + 1)))

num_accepted = 0  # reset acceptance rate counter

# Run training.
for t in range(num_iters):
  # run 5 MCMC iterations before every joint EM update
  for _ in range(5):
    current_state, kernel_results = one_e_step(current_state, kernel_results)
  loss = one_m_step(current_state)
  effect_students_samples[t, :] = current_state[0].numpy()
  effect_instructors_samples[t, :] = current_state[1].numpy()
  effect_departments_samples[t, :] = current_state[2].numpy()
  num_accepted += kernel_results.is_accepted.numpy()
  loss_history[t] = loss.numpy()
  if t % 500 == 0 or t == num_iters - 1:
    print("Iteration: {:>4} Acceptance Rate: {:.3f} Loss: {:.3f}".format(
        t, num_accepted / (t + 1), loss_history[t]))

Warm-Up Iteration:   0 Acceptance Rate: 1.000
Warm-Up Iteration: 500 Acceptance Rate: 0.754
Warm-Up Iteration: 999 Acceptance Rate: 0.707
Iteration:    0 Acceptance Rate: 1.000 Loss: 98220.266
Iteration:  500 Acceptance Rate: 0.703 Loss: 96003.969
Iteration: 1000 Acceptance Rate: 0.678 Loss: 95958.609
Iteration: 1499 Acceptance Rate: 0.685 Loss: 95921.891

Ayrıca içine For döngüsü ısınma yazabilir tf.while_loop ve içine eğitim aşamasını tf.scan veya tf.while_loop daha da hızlı çıkarım için. Örneğin:

@tf.function(autograph=False, jit_compile=True)
def run_k_e_steps(k, current_state, kernel_results):
  _, next_state, next_kernel_results = tf.while_loop(
      cond=lambda i, state, pkr: i < k,
      body=lambda i, state, pkr: (i+1, *one_e_step(state, pkr)),
      loop_vars=(tf.constant(0), current_state, kernel_results)
  )
  return next_state, next_kernel_results

Yukarıda, bir yakınsama eşiği tespit edilene kadar algoritmayı çalıştırmadık. Eğitimin mantıklı olup olmadığını kontrol etmek için, kayıp fonksiyonunun gerçekten eğitim yinelemeleri üzerinde yakınsama eğiliminde olduğunu doğrularız.

plt.plot(loss_history)
plt.ylabel(r'Loss $-\log$ $p(y\mid\mathbf{x})$')
plt.xlabel('Iteration')
plt.show()

Ayrıca, Markov zinciri Monte Carlo algoritmasının belirli gizli boyutlar arasındaki yörüngesini gösteren bir izleme grafiği kullanıyoruz. Aşağıda, belirli eğitmen etkilerinin gerçekten anlamlı bir şekilde ilk durumlarından uzaklaştığını ve durum uzayını keşfettiğini görüyoruz. İz grafiği ayrıca, etkilerin eğitmenler arasında farklılık gösterdiğini ancak benzer karıştırma davranışına sahip olduğunu gösterir.

for i in range(7):
  plt.plot(effect_instructors_samples[:, i])

plt.legend([i for i in range(7)], loc='lower right')
plt.ylabel('Instructor Effects')
plt.xlabel('Iteration')
plt.show()

eleştiri

Yukarıda, modeli yerleştirdik. Şimdi, modeli keşfetmemizi ve daha iyi anlamamızı sağlayan verileri kullanarak uygunluğunu eleştirmeye bakıyoruz. Bu tür bir teknik, her bir veri noktası için modelin tahminleri ile temel gerçek arasındaki farkı çizen artık grafiğidir. Model doğruysa, aralarındaki fark standart normal dağılıma sahip olmalıdır; çizimdeki bu modelden herhangi bir sapma, model uyumsuzluğunu gösterir.

Artık grafiği, ilk önce, rastgele etkiler üzerindeki önceki dağılımı, daha sonra verilen eğitim verileriyle değiştiren, derecelendirmeler üzerinde sonsal tahmin dağılımı oluşturarak oluşturuyoruz. Özellikle, modeli ileriye doğru çalıştırırız ve çıkarsanan sonsal araçları ile önceki rastgele etkilere olan bağımlılığını keseriz.²

lmm_test = lmm_jointdist(features_test)

[
    effect_students_mean,
    effect_instructors_mean,
    effect_departments_mean,
] = [
     np.mean(x, axis=0).astype(np.float32) for x in [
       effect_students_samples,
       effect_instructors_samples,
       effect_departments_samples
       ]
]

# Get the posterior predictive distribution
(*posterior_conditionals, ratings_posterior), _ = lmm_test.sample_distributions(
    value=(
        effect_students_mean,
        effect_instructors_mean,
        effect_departments_mean,
))

ratings_prediction = ratings_posterior.mean()

Görsel incelemede, artıklar bir şekilde standart-normal dağılımlı görünüyor. Bununla birlikte, uyum mükemmel değildir: kuyruklarda normal dağılımdan daha büyük olasılık kütlesi vardır, bu da modelin normallik varsayımlarını gevşeterek uyumunu iyileştirebileceğini gösterir.

O model puanlara bir normal dağılım kullanmak en yaygın olmasına rağmen özellikle, InstEval veri seti, verinin daha yakından bakmak o ders değerlendirme derecelendirme Bu işlem, kullandığımız gerektiğini önermektedir 1 ila 5 gerçektir sıralı değerler içindedir ortaya koymaktadır bir sıralı dağılım, hatta göreli sıralamayı atmak için yeterli veriye sahipsek Kategorik. Bu, yukarıdaki modelde tek satırlık bir değişikliktir; aynı çıkarım kodu geçerlidir.

plt.title("Residuals for Predicted Ratings on Test Set")
plt.xlim(-4, 4)
plt.ylim(0, 800)
plt.hist(ratings_prediction - labels_test, 75)
plt.show()

Modelin bireysel tahminleri nasıl yaptığını keşfetmek için öğrenciler, eğitmenler ve bölümler için etkilerin histogramına bakıyoruz. Bu, bir veri noktasının özellik vektöründeki bireysel öğelerin sonucu nasıl etkileme eğiliminde olduğunu anlamamızı sağlar.

Şaşırtıcı olmayan bir şekilde, aşağıda her öğrencinin bir eğitmenin değerlendirme notu üzerinde genellikle çok az etkisi olduğunu görüyoruz. İlginçtir ki, bir eğitmenin ait olduğu bölümün etkisinin büyük olduğunu görüyoruz.

plt.title("Histogram of Student Effects")
plt.hist(effect_students_mean, 75)
plt.show()

plt.title("Histogram of Instructor Effects")
plt.hist(effect_instructors_mean, 75)
plt.show()

plt.title("Histogram of Department Effects")
plt.hist(effect_departments_mean, 75)
plt.show()

Dipnotlar

¹ Doğrusal karışık efekt modelleri, marjinal yoğunluğunu analitik olarak hesaplayabildiğimiz özel bir durumdur. Bu öğreticinin amaçları doğrultusunda, olasılığın Normal yerine Kategorik olacak şekilde genişletilmesi gibi analitik olmayan marjinal yoğunluklara daha kolay uygulanan Monte Carlo EM'yi gösteriyoruz.

² Basit olması için, modelin yalnızca bir ileri geçişini kullanarak tahmine dayalı dağılımın ortalamasını oluşturuyoruz. Bu, arka ortalama üzerinde koşullandırma ile yapılır ve doğrusal karışık efekt modelleri için geçerlidir. Bununla birlikte, bu genel olarak geçerli değildir: sonsal öngörücü dağılımın ortalaması tipik olarak inatçıdır ve arka örnekler verilen modelin çoklu ileri geçişlerinde ampirik ortalamanın alınmasını gerektirir.

Teşekkür

Bu eğitimde başlangıçta Edward 1,0 (yazılmış kaynak ). Bu sürümü yazmaya ve revize etmeye katkıda bulunan herkese teşekkür ederiz.

Referanslar

1. Douglas Bates ve Martin Machler ve Ben Bolker ve Steve Walker. lme4 Kullanarak Doğrusal Karma Etkili Modelleri Uydurma. İstatistiksel Yazılım, 67 Dergisi (1): 1-48, 2015.

2. Arthur P. Dempster, Nan M. Laird ve Donald B. Rubin. EM algoritması aracılığıyla eksik verilerden maksimum olasılık. Kraliyet İstatistik Derneği Dergisi, Seri B (Metodolojik), 1-38, 1977.

3. Andrew Gelman ve Jennifer Hill. Regresyon ve çok düzeyli/hiyerarşik modeller kullanarak veri analizi. Cambridge Üniversitesi Yayınları, 2006.

4. David A. Harville. Varyans bileşeni tahmini ve ilgili problemlere maksimum olabilirlik yaklaşımları. Amerikan İstatistik Derneği Dergisi, 72 (358): 320-338, 1977.

5. Michael I. Jordan. Grafik Modellere Giriş. Teknik Rapor, 2003.

6. Nan M. Laird ve James Ware. Boylamsal veriler için rastgele etki modelleri. Biyometri, 963-974, 1982.

7. Greg Wei ve Martin A. Tanner. EM algoritmasının bir Monte Carlo uygulaması ve yoksul adamın veri büyütme algoritmaları. Amerikan İstatistik Derneği Dergisi, 699-704, 1990.