[Basic of IRT using R] 7. Test Calibration

7.1 Introduction

우리는 여태까지 하나의 모수를 안다고 가정하고 다른 모수를 추정하였다.

(능력 모수를 안다고 가정하고, 난이도, 추측도, 변별도를 추정, 난이도, 변별도, 추측도를 안다고 가정하고 능력모수를 추정)

그러나 현실에서 안타깝게 이를 미리 알 수가 없다.

그렇기에 우리의 목적은 능력모수와 문항모수를 각각 추정하는 것이다.

이 과정을 눈금메기기(calibration)라고 한다.

 

 

7.2 The Test Calibration Process

결합 최대 우도 추정 방법을 사용하여 두 모수를 추정한다.

J개의 문항으로 문항모수를 추정하고, N개의 시험자의 능력모수를 추정한다.

 

 

7.2.1 The metric Problem

모수를 추정함에 있어서 이 추정방법은 하나의 값을 가지지 않는다.

그렇기에 하나의 기준을 추가하여 중간점과 측정단위를 결정할 필요가 있다.

 

7.3 Test Calibration Under the Rasch Model

Rasch model을 쓰면 난이도만 고려하면 되기에 만들기가 쉽다.

만점이거나 0점이면 추정이 안되기에 이런 문항은 제거를 한다.

원점수가 같다면, 같은 능력을 가진걸로 Rasch모형에서는 간주한다.

 

 

7.4 Summary of the Test Calibration Process

Rasch 모델에서는 중간을 0, 측정단위를 1로해서 한다.

 

 

7.5 Computer Session

for k in range(K):
  print(f'cycle k={k}\n')
  for j in range(J):
    for t in range(T):
      sumfp=0
      sumfpq=0
      for g in range(G):
        p=1/(1+np.exp(-(theta[g]-b[j])))
        sumfp= sumfp+f[g]*p
        sumfpq=sumfpq+f[g]*p*(1-p)
      deltab=(s[j]-sumfp)/sumfpq
      b[j]=b[j]-deltab
      if(abs(deltab)<convb):
        break
  b=b-np.mean(b)
  for g in range(G):
    for t in range(T):
      sump=0
      sumpq=0
      for j in range(J):
        p=1/(1+np.exp(-(theta[g]-b[j])))      
        sump=sump+p
        sumpq=sumpq-p*(1-p)
      deltat=(g-sump)/sumpq
      theta[g]=theta[g]-deltat
      if(abs(deltat)<convt):
        break
    abd=abs(b-oldb)
    if(sum(abd)<convabd):
      break
    else:
      oldb=b
  b=b*((J-1)/J)
  for j in range(J):
    print(f'b({j})={b[j]}\n')
  for g in range(G):
    for t in range(T):
      sump=0
      sumpq=0
      for j in range(J):
        p=1/(1+np.exp(-(theta[g]-b[j])))
        sump=sump+p
        sumpq=sumpq-p*(1-p)
      deltat=(g-sump)/sumpq
      theta[g]=theta[g]-deltat
      if(abs(deltat)<convt):
        break
  theta=theta*((J-2)/(J-1))
  for g in range(G):
    print(f'theta({g})={theta[g]}\n')

 

코드를 돌렸는데 책 처럼 안나온다 분하다.

 

 

 

함수화하기

import numpy as np

def estimate_irt_parameters(s, f):
    J = len(s)
    G = len(f)
    K = 25
    T = 10

    b = np.log((np.sum(f) - s) / s)
    b = b - np.mean(b)
    old_b = np.copy(b)

    theta = np.arange(1, G + 1, 1)
    for g in range(1, G + 1):
        theta[g - 1] = np.log(g / (J - g))

    for k in range(1, K + 1):
        convabd = 0.01
        print("cycle k=", k)

        b = stage1(b, theta, s, f)
        b = b - np.mean(b)
        theta = stage2(theta, b)

        abd = np.abs(b - old_b)
        if np.sum(abd) < convabd:
            break
        else:
            old_b = np.copy(b)

    b = b * ((J - 1) / J)
    for j in range(1, J + 1):
        print("b(", j, ")=", b[j - 1])

    print("mean(b)=", np.mean(b))
    print("sd(b)=", np.std(b))
    print("J=", J)

    theta = stage2(theta, b)
    theta = theta * ((J - 2) / (J - 1))
    for g in range(1, G + 1):
        print("theta(", g, ")=", theta[g - 1])

    print("mean(theta)=", np.mean(np.repeat(theta, f)))
    print("sd(theta)=", np.std(np.repeat(theta, f)))
    print("N=", np.sum(f))
    print("f=", f)

def stage1(b, theta, s, f):
    J = len(b)
    G = len(theta)
    T = 10

    for j in range(1, J + 1):
        convb = 0.01
        for t in range(1, T + 1):
            sumfp = 0
            sumfpq = 0
            for g in range(1, G + 1):
                p = 1 / (1 + np.exp(-(theta[g - 1] - b[j - 1])))
                sumfp += f[g - 1] * p
                sumfpq += f[g - 1] * p * (1 - p)

            deltab = (s[j - 1] - sumfp) / sumfpq
            b[j - 1] = b[j - 1] - deltab

            if np.abs(deltab) < convb:
                break

    return b

def stage2(theta, b):
    G = len(theta)
    J = len(b)
    T = 10

    for g in range(1, G + 1):
        convt = 0.01
        for t in range(1, T + 1):
            sump = 0
            sumpq = 0
            for j in range(1, J + 1):
                p = 1 / (1 + np.exp(-(theta[g - 1] - b[j - 1])))
                sump += p
                sumpq -= p * (1 - p)

            deltat = (g - sump) / sumpq
            theta[g - 1] = theta[g - 1] - deltat

            if np.abs(deltat) < convt:
                break

    return theta

# Example usage with simulated data
s = np.array([13, 8, 8, 5, 10, 7, 7, 6, 7, 3])
f = np.array([1, 2, 2, 4, 1, 1, 0, 0, 4])