[PYTHON] Prüfungsmathematik Teil 5 (Schätzung des Prüflingsparameters)

Dies ist eine Fortsetzung von Testmathematik Teil 4 (Implementierung der Problemparameterschätzung).

Letztes Mal war es "Implementierung der Problemparameterschätzung des 3PL-Modells". Diesmal handelt es sich um eine "Schätzung des Fähigkeitsparameters des Prüflings".

Die verwendete Umgebung ist

• python 3.8
• numpy 1.19.2
• matplotlib 3.3.1

ist.

Theorie

Problemstellung

Wenn die Fragenparameter $ a, b, c $ bekannt sind, wird der 3PL-Modell-Testteilnehmerparameter $ \ theta_j $ aus dem Antwortvektor $ u_j $ auf die Frage geschätzt.

Zielfunktion

Hier werden wir es durch die wahrscheinlichste Schätzung lösen. Wahrscheinlichkeit, dass der Testteilnehmer $ j $ die Frage $ i $ im 3PL-Modell von $ P_ {ij} $ richtig beantwortet, ist die Wahrscheinlichkeit, wenn $ Q_ {ij} = 1 --P_ {ij} $

\begin{align}
\Pr\{U_j = u_j|\theta_j, a, b, c\} &= \prod_{i} \Pr\{U_{ij} = u_{ij}|\theta, a, b, c\}\\
&= \prod_{i}P_{ij}^{u_{ij}}Q_{ij}^{1-u_{ij}}
\end{align}

Daher ist die logarithmische Wahrscheinlichkeit

\begin{align}
\mathcal{L}(u_j, \theta_j, a, b, c) &= \ln \Pr\{U_j = u_j|\theta_j, a, b, c\}\\
&= \sum_{i}u_{ij}\ln P_{ij} + (1-u_{ij})\ln Q_{ij}
\end{align}

Es wird sein. Wo der gewünschte Parameter $ \ hat {\ theta j} $ ist

\begin{align}
\hat{\theta_j} = \arg \max_{\theta}\mathcal{L}(u_j, \theta, a, b, c)
\end{align}

Es wird sein.

Differenzkoeffizient

Berechnen Sie die Mikrofaktoren, um das Problem zu lösen. Wenn $ \ Partial_ \ Theta: = \ frac {\ Partial} {\ Partial \ Theta} $

\begin{align}
\partial_\theta\mathcal{L}(u_j, \theta, a, b, c) &= \sum_i a_i\left(\frac{u_{ij}}{P_{ij}} - 1\right)P_{ij}^* \\
\partial_\theta^2\mathcal{L}(u_j, \theta, a, b, c) &= \sum_i a_i^2\left(\frac{c_iu_{ij}}{P_{ij}^2} - 1\right)P_{ij}^* Q_{ij}^*
\end{align}

Es wird sein. Wobei $ P ^ \ * \ _ {ij}, Q ^ \ * \ _ {ij} $ die Wahrscheinlichkeit ist, dass der Kandidat $ j $ die Frage $ i $ im 2PL-Modell korrekt beantwortet. Von hier aus sollte die Lösung $ \ Partial_ \ Theta \ Mathcal {L} = 0, \ Partial_ \ Theta ^ 2 \ Mathcal {L} <0 $ sein.

Lösung

Hier wird die Berechnung nach der Newton-Raphson-Methode durchgeführt. Das spezifische Verfahren ist wie folgt.

1. Bestimmen Sie den Wert mit einer Zufallszahl als $ \ theta $.
2. $ \ theta ^ {(neu)} = \ theta ^ {(alt)} - \ partiell_ \ theta \ mathcal {L} (\ theta ^ {(alt)}) / \ partiell_ \ theta ^ 2 \ mathcal { Der Wert wird nacheinander mit L} (\ theta ^ {(alt)}) $ aktualisiert und endet mit $ \ partiell_ \ theta \ mathcal {L} <\ delta $.
3. Bestimmen Sie, ob $ \ partielle_ \ theta ^ 2 \ mathcal {L} <0 $ und ob der Wert divergiert und wenn die Bedingungen nicht erfüllt sind, von vorne beginnen.
4. Wenn der Wert auch nach Wiederholung von $ N $ nicht gefunden wird, wird keine Lösung angegeben.

Implementierung

Ich habe es mit Python wie folgt implementiert.

import numpy as np
from functools import partial

#Definition des konstanten Deltas:Konvergenzurteil, Theta_:Divergenzurteil, N.:Wiederholen Sie das Urteil
delta = 0.0001
Theta_ = 20
N = 20
def search_theta(u_i, item_params, trial=0):
    #Gibt None zurück, wenn die Anzahl der Wiederholungen die angegebene Anzahl erreicht
    if trial == N:
        return None
    #Bestimmen Sie Theta mit einer Zufallszahl.
    theta = np.random.uniform(-2, 2)
    #NR-Methode
    for _ in range(100):
        P3_i = np.array([partial(L3P, x=theta)(*ip) for ip in item_params])
        P2_i = np.array([partial(L2P, x=theta)(*ip) for ip in item_params])
        a_i = item_params[:, 0]
        c_i = item_params[:, 2]
        res = (a_i *( u_i / P3_i - 1) * P2_i).sum()
        d_res = (a_i * a_i * ( u_i  * c_i/ P3_i / P3_i  - 1) * P2_i * (1 - P2_i)).sum()
        theta -= res/d_res
        #Konvergenzurteil
        if abs(res) < delta:
            if d_res < -delta and -Theta_ < theta < Theta_:
                return theta
            else:
                break
    return search_theta(u_i, item_params, trial + 1)

Ausführung und Ergebnisse

Die numerische Berechnung wurde unter Verwendung der obigen Funktion durchgeführt. Als Problemparameter für die Ausführung vorherige

Wurde benutzt.

params = np.array(
    [[ 3.49633348,  1.12766137,  0.35744497],
     [ 2.06354365,  1.03621881,  0.20507606],
     [ 1.64406087, -0.39145998,  0.48094315],
     [ 1.47999466,  0.9592384 ,  0.18384673],
     [ 1.44474336,  1.12406269,  0.31475672],
     [ 3.91285332, -1.09218709,  0.18379076],
     [ 1.44498535,  1.50705016,  0.20601461],
     [ 2.37497907,  1.61937999,  0.10503096],
     [ 3.10840278,  1.69962392,  0.22051818],
     [ 1.79969976,  0.06053145,  0.29944448]]
)

In Bezug auf die Schätzung des Prüflingsparameters gibt es diesmal tatsächlich nur 10 Fragen, und die möglichen Untersuchungsergebnisse als Eingabe reichen von "[0, 0, ..., 0]" bis "[1, 1, ...". , 1] `Es gibt nur 1024 Wege. Tatsächlich gibt es nur zwei richtige und falsche Antworten. Wenn also die Anzahl der Fragen $ I $ beträgt, beträgt die mögliche Eingabe $ 2 ^ I $. Daher ist es unmöglich, den reellen Zahlenparameter $ \ theta $ mit vollständiger Genauigkeit zu sehen. Nehmen wir zum Beispiel an, der Parameter eines Testteilnehmers liegt bei "0,1224" und das Ergebnis ist "[0, 1, 1, 0, 1, 1, 1, 0, 0, 1]". Hier,

search_theta(np.array([0, 1, 1, 0, 1, 1, 1, 0, 0, 1]), params)

Das Ergebnis ist ungefähr "0,8167". Wenn Sie in der Grafik zeichnen, sieht es folgendermaßen aus:

import matplotlib.pyplot as plt
y = []
y_ = []
x = np.linspace(-3, 3, 201)
u_ = np.array([0, 1, 1, 0, 1, 1, 1, 0, 0, 1])
for t in x:
    theta = t
    P3_i = np.array([partial(L3P, x=theta)(*ip) for ip in params])
    P2_i = np.array([partial(L2P, x=theta)(*ip) for ip in params])
    a_i = params[:, 0]
    #Log-Wahrscheinlichkeit
    res = (u_ * np.log(P3_i) + (1 - u_) * np.log(1 - P3_i)).sum()
    #Differenzkoeffizient
    res_ = (a_i *( u_ / P3_i - 1) * P2_i).sum()
    y.append(res)
    y_.append(res_)


# plot
#
plt.plot(x, y_, label="dL")
plt.plot(x, x * 0, label="0")
plt.xlabel("theta")
plt.ylabel("val")
plt.legend()
plt.show()
#
plt.plot(x, y, label="L")
plt.xlabel("theta")
plt.ylabel("val")
plt.legend()
plt.show()

n_digits = 10
num = 106
u_ = np.array([int(i) for i in f'{num:0{n_digits}b}'])

Die logarithmische Wahrscheinlichkeit lag tatsächlich bei "0,1224", es handelt sich also um eine ziemlich hohe Zahl. Dies liegt daran, dass ich das Glück hatte, Q2 und Q5 richtig zu beantworten. Dies ist wahrscheinlich auf die geringe Anzahl von Fragen zurückzuführen. Je höher die Anzahl der Fragen ist, desto einfacher ist es, eine genauere Schätzung zu erhalten. Es ist eine Binärdatei, die für die Bonus-Eingabe verwendet wird, aber Sie können beispielsweise "Array ([0, 0, 0, 1, 1, 0, 1, 0, 1, 0])" erhalten. 0 <= num <= 1023 Jetzt können Sie den optimalen Wert für alle Eingänge sehen. Einige, wie z. B. "[1, 1, ..., 1]", geben jedoch keine anständigen Werte an.

Fazit

Dies ist die "Mathematical Examination" -Serie, die ich über 5 Artikel geschrieben habe, aber dies ist das Ende. Vielen Dank, dass Sie diesen Artikel und die vorherigen Artikel gelesen haben. Die Item-Reaktionstheorie ist tiefgreifend. Was ist zum Beispiel mit Daten, die nicht alle beantworten (fehlende Zähne)? Was ist, wenn es in erster Linie nicht binär ist, mehrstufig oder die Daten in reellen Zahlen ausgegeben werden? Verschiedene Anwendungen und Entwicklungen sind möglich. Wenn ich die Gelegenheit dazu habe, würde ich gerne darüber lernen und einen Artikel schreiben. Wenn Sie Fragen oder Bedenken haben, können Sie diese gerne kommentieren oder Korrekturen anfordern.

Verweise

• Buch Item Reaction Theory / Theory-Test Mathematics (Statistische Bibliothek) (amazon.co.jp)
• Buch Einführung in die Theorie der Gegenstandsreaktion (2. Auflage) (Statistische Bibliothek) (amazon.co.jp)