von Reinhold Hatzinger - eRm

Manual zum Softwarepackage eRm
(extended Rasch modeling)
Anwendung des Rasch-Modells (1-PL Modell)
- deutsche Version
Herbert Poinstingl, Patrick Mair & Reinhold Hatzinger
2007
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Herbert Poinstingl
[email protected]
Arbeitsbereich Psychologische Diagnostik
Fakultät für Psychologie der Universität Wien
Liebiggasse 5, A-1010 Wien
Patrick Mair
[email protected]
Wirtschaftsuniversität Wien
Department für Statistik und Mathematik
Augasse 2-6, A-1090 Wien
Reinhold Hatzinger
[email protected]
Wirtschaftsuniversität Wien
Department für Statistik und Mathematik
Augasse 2-6, A-1090 Wien
2
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Geleitwort
Als „Mentor“ des vorliegenden Manuals zum Auswertungsprogramm eRm in Buchform ist es
mir eine Freude, ein Geleitwort zu schreiben. Die genauen Hintergründe, wie es zu diesem
Manual gekommen ist, haben die Verfasser in ihrem Vorwort kurz ausgeführt. Noch weiter
zurückgehende „Hintergründe“ möchte ich hier ansprechen.
Vielen Interessenten am Rasch-Modell – genauer: am dichotomen logistischen
Testmodell von Rasch, heutzutage fast prägnanter, weil nicht verwechselbar mit anderen
darauf aufbauenden Modellen als 1-PL Modell bezeichnet – ist nicht bekannt, wie und durch
wen und damit von wo aus es seinen „Eroberungszug“ in die psychologische Testtheorie
begann. Quelle ist freilich das berühmte Buch von Georg Rasch, das nach Drängen seiner
Schüler endlich 1960 auf den Markt kam und 1980 neu aufgelegt wurde. Allerdings wäre nicht
- neben seinem Schüler Erling B. Andersen - Gerhard Fischer aus Wien (Institut für
Psychologie, Universität Wien) gewesen, hätte es nicht nur außerhalb des deutschsprachigen
Raums lange gedauert bis sich das Modell endlich über Verallgemeinerungen und
Anwendungen in der PISA-Studie „durchsetzte“. Ohne Gerhard Fischer also, der einen
mehrmonatigen Studienaufenthalt bei Georg Rasch in Kopenhagen gegen Ende der 60er Jahre
verbrachte, hätte man das Rasch-Modell auch im deutschsprachigen Raum kaum zur Kenntnis
genommen. Seine, Gerhard Fischers Bücher, vor allem jenes aus 1974, und er selbst mit
seinen Schülern „betrieb“ emsig die Anwendung des Rasch-Modells. Von Wien aus
verbreitete es sich in die Niederlande; via Hans Spada, einem der Schüler von Fischer, nach
Kiel. Andere Fischer-Schüler sind in der Literatur bekannt: Hartmann Scheiblechner, Wilhelm
Kempf, Anton Formann und ich selbst sowie später Georg Gittler, noch später Norbert Tanzer
und Ivo Ponocny. In den 80er Jahren entstanden dann auch erste publizierte und verlagsmäßig
vertriebene Tests, die von vornherein nach dem Rasch-Modell kalibriert worden sind: WMT
von Formann, AID von mir und 3DW von Gittler (alle noch immer in Wien); in der
Zwischenzeit sind es deren mehr aus Wien stammende geworden.
So gesehen ist Wien ein wichtiger Ausgangspunkt zur Verbreitung des Rasch-Modells
gewesen. Diesem Umstand soll das Umschlagbild der vorliegenden Buchform des Manuals
zum eRm Rechnung tragen. Der Kreis schließt sich, indem dieses Programm – auf das ein
Mitarbeiter von mir, sicher nicht zufällig, weil systematisch suchend, doch aber überraschend,
was die Adresse betrifft, gestoßen ist – von zwei Mitarbeitern des Departments für Statistik
und Mathematik der Wirtschaftsuniversität Wien stammt, die beide ebenfalls an der Fakultät
3
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
für Psychologie der Universität Wien studierten; Patrick Mair verfasste nach seiner Promotion
in Statistik seine Diplomarbeit in Psychologie bei Formann, Reinhold Hatzinger vor seiner
Habilitation in Statistik seine Dissertation mit mir als Betreuer bei Fischer.
Möge diese Software, unterstützt mit dem vorliegenden Manual, erst recht zur
Verbreitung des Rasch-Modells beitragen.
Klaus D. Kubinger
(Arbeitsbereich Psychologische Diagnostik
samt Test- und Beratungsstelle
Fakultät für Psychologie, Universität Wien)
4
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
1 Vorwort
Als am Arbeitsbereich Psychologische Diagnostik (Fakultät für Psychologie, Universität
Wien; www.univie.ac.at/psychologie/diagnostik) bzw. an der angeschlossenen Test- und
Beratungsstelle
(www.testzentrum.at
)
der
Bedarf
an
einem
leistungsstärkeren
Softwareprogramm zur Anwendung des Rasch-Modells (1-PL Modell) entstand (als es mit
dem LPCM-Win (Seliger-Ponocny & Fischer, 1998) gegeben war), wurde man bei einer
Internetrecherche fündig: Patrick Mair und Reinhold Hatzinger vom Arbeitsbereich
Quantitative
Research
Methods,
Department
für
Statistik
und
Mathematik
der
Wirtschaftsuniversität Wien waren gerade an der Entwicklung eines in „R“ anwendbaren
Programms namens eRm (extended Rasch modeling).
Daraufhin kam es zu einer sehr befruchtenden Zusammenarbeit zwischen Herbert
Poinstingl und Mitarbeiter(inne)n der Test- und Beratungsstelle einerseits und den
Entwicklern Mair & Hatzinger andererseits. Die jahre- bis jahrzehntelange Erfahrung in der
Kalibrierung von Tests nach dem Rasch-Modell seitens des Leiters der Test- und
Beratungsstelle, Klaus Kubinger, und seiner Mitarbeiter(innen) konnten bei der Fertigstellung
berücksichtigt werden. So wurden vielfache Routine-Bedürfnisse sowie zahlreiche Daten„Imponderabilien“ weitergegeben und gleichzeitig an eigenen Auswertungen die praktische
Bewährung von eRm erprobt. Dieser monatelange rekursive Prozess führte zu einer für den
praktischen Einsatz empfehlenswerten Programmversion. Allerdings bedarf der Anwender,
zumeist Psycholog(inn)en ohne viel Programmiererfahrung und -interesse nicht nur einer
theoriegeleitet optimal programmierten Software, sondern auch einer benutzerfreundlichen.
Der Benutzerfreundlichkeit dient nun das vorliegende Manual. Es sollte mit ihm jedem
Anwender schnell und leicht möglich sein, Analysen nach dem Rasch-Modell
zu
bewerkstelligen.
Dass eRm als OpenSource-Software nicht nur gratis, sondern der Quellcode auch für
jedermann einsehbar ist, kann als ein besonderes Qualitätsmerkmal gewertet werden. Das
bedingt zwar laufende Updates – abgesehen davon, dass eRm weit mehr zu leisten imstande
ist als Analysen nach dem (einfachen) Rasch-Modell, also dem 1-PL Modell, trotzdem wird
aber versucht, den in diesem Manual gegebenen Informationsstand möglichst lange aktuell zu
halten. D.h., neuere Versionen als 0.9.5 mit Erweiterungen werden jedesmal genau darauf
5
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
hinweisen, was sich in der Benutzung ändert bzw. wird die Version 0.9.5 (ausgenommen
allfällige
Fehlerkorrekturen)
für
längere
Zeit
www.univie.ac.at/psychologie/diagnostik downloadbar sein.
6
auch
auf
der
Homepage
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
2 Danksagungen
Ein besonderer Dank geht an Herrn Univ.-Prof. Dr. Mag. Klaus Kubinger, ohne dessen
Energie und Engagement dieses Buch nicht entstanden bzw. niemals fertig geworden wäre.
Ein besonderer Dank der Autoren geht an Frau Mag. Hannelore Koch, die im letzten Moment
noch zahlreiche Druckfehler entdeckt hat.
Weiters danken wir auch an Herrn Andreas Schneiderbauer für seine Korrekturarbeit.
Zuletzt bedanken sich die Autoren bei Frau Veronika Marek und Herrn Wolfgang Steiner für
die Gestaltung des Titelbildes.
7
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
3 Inhaltsverzeichnis
1
2
3
4
5
6
Vorwort------------------------------------------------------------------------------------------------5
Danksagungen ----------------------------------------------------------------------------------------7
Inhaltsverzeichnis ------------------------------------------------------------------------------------8
Lexikalische Anmerkungen ------------------------------------------------------------------------9
Grundsätzliches ------------------------------------------------------------------------------------ 11
GNU „R“ -------------------------------------------------------------------------------------------- 12
6.1
Voraussetzungen ----------------------------------------------------------------------------- 14
6.2
Plattformen für „R“ -------------------------------------------------------------------------- 15
6.3
Die Installation von „R“ & eRm (unter WINDOWS) ---------------------------------- 16
6.4
Programmpakete laden ---------------------------------------------------------------------- 20
6.5
Benutzeroberflächen unter „R“ für WINDOWS ---------------------------------------- 22
6.5.1
JGR („Java Gui for R“) --------------------------------------------------------------- 22
6.5.2
Der R-Commander--------------------------------------------------------------------- 24
6.5.3
Exkurs: Teaching Demos ------------------------------------------------------------- 28
6.6
Objekte in „R“-------------------------------------------------------------------------------- 30
6.7
Wichtige Befehle für „R“ ------------------------------------------------------------------- 32
6.8
Rechnen mit „R“ ----------------------------------------------------------------------------- 35
6.9
„R“-Software-Pakete im Bereich der IRT------------------------------------------------ 40
7
Daten austauschen --------------------------------------------------------------------------------- 41
7.1
Der Datenimport ----------------------------------------------------------------------------- 41
7.2
Der Datenexport – der write()-Befehl----------------------------------------------------- 49
7.3
Workspace – eine Möglichkeit zur Datenspeicherung --------------------------------- 51
8
extended Rasch modeling eRm------------------------------------------------------------------- 54
8.1
eRm - extended Rasch modeling (Mair & Hatzinger, 2006)-------------------------- 55
8.2
Die Analyse eines Rasch-Modells (RM) ------------------------------------------------- 57
8.3
Die Befehle print(), summary() und die Struktur von Rm-Objekten ----------------- 62
8.4
Möglichkeiten des Befehls RM() ---------------------------------------------------------- 68
8.5
Weitere Berechungsmöglichkeiten -------------------------------------------------------- 70
8.5.1
Schätzung von Personenparameter -------------------------------------------------- 70
8.5.2
Der bedingte Likelihood-Quotiententest (nach Andersen)----------------------- 78
8.5.3
Der Grafische Modelltest (Rasch) --------------------------------------------------- 85
8.5.4
Der Waldtest---------------------------------------------------------------------------- 92
8.5.5
Personfit und Itemfit------------------------------------------------------------------- 96
8.5.6
Die Informationsindices -------------------------------------------------------------- 99
8.5.7
Weitere grafische Möglichkeiten ---------------------------------------------------100
9
Untergruppen und missing data -----------------------------------------------------------------103
9.1
Rasch-Modell-Analyse einer Datenmatrix mit Gruppen ------------------------------105
9.2
Der bedingte LQT (Andersen) mit Untergruppen--------------------------------------107
9.3
Personenparameter-Schätzung bei Untergruppen --------------------------------------109
10
Das Rm-Objekt ---------------------------------------------------------------------------------114
11
Objekte in eRm (von Reinhold Hatzinger) -------------------------------------------------116
12
Literaturverzeichnis----------------------------------------------------------------------------119
13
Empfehlenswerte Vertiefungsliteratur ------------------------------------------------------120
14
Nützliche Webseiten---------------------------------------------------------------------------121
15
FAQ – Frequently Asked Questions --------------------------------------------------------122
16
Pakete für die Psychometrie ------------------------------------------------------------------125
17
Matrix mat1 -------------------------------------------------------------------------------------128
18
Matrix mat2 -------------------------------------------------------------------------------------129
19
Abbildungsverzeichnis ------------------------------------------------------------------------130
8
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
4 Lexikalische Anmerkungen
1. Wichtige Hinweise erscheinen im Manual folgendermaßen
Wichtig: So sehen wichtige Hinweise aus.
2. Programmcode bzw. Beispiele haben das folgende Aussehen
Beispiele zu Befehlen, die direkt in die R-Benutzeroberfläche eingegeben werden können,
werden folgendermaßen dargestellt.
Beispiel/Code:
for(i in 1:10) print(c(i,i*i))
3. Darstellung von Menüpunkten
Menüpunkt:
Menüpunkte, die in der Menüleiste oder einem Submenü ausgewählt werden
können, sind in diesem Format dargestellt.
4. Kommentare beginnen mit dem Zeichen „#“.
# Kommentare zu den Dateien haben dieses Format
5. Weitere Informationen zu einem Thema haben folgendes Aussehen
Info: Weitergehende Informationen werden in dieser Formatierung dargestellt.
9
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
6. Zusammenfassungen haben folgendes Erscheinungsbild
Zusammenfassung: So sehen Zusammenfassungen aus.
7. Tipps haben folgendes Erscheinungsbild
Tipp: Tipps zu “R“ und eRm haben dieses Format.
8. Ausgaben haben folgendes Erscheinungsbild
Ausgabe:
Bildschirmausgaben von „R“ & eRm haben diese Formatierung. Bei den
einführenden
Beispielen
werden
allerdings
der
Einfachheit
Missverständnissen vorzubeugen vor allem „Screenshots“ verwendet.
9. Platz für eigenen Notizen
An diesen Stellen kann der Leser eigenen Notizen in das Buch eintragen.
Eigene Notizen:
10
halber
und
um
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
5 Grundsätzliches
Dieses Handbuch bezieht sich auf eRm: extended Rasch modeling. R package version 0.9.5
(Mair, P. & Hatzinger, R., 2007) erreichbar unter http://CRAN.R-project.org/.
Die Autoren übernehmen keine Gewährleistung oder Haftung für etwaige Schäden,
Folgeschäden oder Ausfälle, die entstehen können.
Die Autoren übernehmen außerdem keinerlei Gewähr für die Aktualität, Korrektheit,
Vollständigkeit oder Qualität der bereitgestellten Informationen. Haftungsansprüche gegen
die Autoren, welche sich auf Schäden materieller oder ideeller Art beziehen, die durch die
Nutzung oder Nichtnutzung der dargebotenen Informationen bzw. durch die Nutzung
fehlerhafter und unvollständiger Informationen verursacht wurden, sind grundsätzlich
ausgeschlossen, sofern seitens der Autoren kein nachweislich vorsätzliches oder grob
fahrlässiges Verschulden vorliegt.
Bei direkten oder indirekten Verweisen auf fremde Webseiten ("Hyperlinks"), die außerhalb
des Verantwortungsbereiches der Autoren liegen, würde eine Haftungsverpflichtung
ausschließlich in dem Fall in Kraft treten, in dem die Autoren von den Inhalten Kenntnis
haben.
Wichtig: der Pfeil und das Gleichheitszeichen: Bei der Übergabe von Werten, Objekten etc.
an Variablen (z.B. x=3 oder x<=“ und der
x<-3) ist zu beachten, dass das Gleichheitszeichen „=
Pfeil „<
<-“ bei der interaktiven Eingabe von Befehlen in „R“ gleiche Wirkung haben. Aus
Formatierungsgründen
wird in diesem
Manual „=
=“ verwendet.
Der Standard-
Zuweisungsoperator ist allerdings der Pfeil „<
<-“ und dem Leser wird hier explizit
empfohlen, diesen zu verwenden (nicht zuletzt, da das Gleichheitszeichen „=
=“ im
Gegensatz zum Pfeil „<
<-“ nicht überall verwendet werden kann).
11
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
6 GNU „R“
Auf der Homepage von CRAN (dem Netzwerk für R) findet man die folgenden Definitionen
für die Begriffe CRAN und GNU „R“
-
“CRAN is a network of ftp and web servers around the world that store identical, upto-date, versions of code and documentation for R.”
-
“R is ‘GNU S', a freely available language and environment for statistical computing
and graphics which provides a wide variety of statistical and graphical techniques:
linear and nonlinear modelling, statistical tests, time series analysis, classification,
clustering, etc.”
(erreichbar auf http://www.cran.r-project.org/, 31.08.2007)
GNU „R“ ist eine integrierte Sammlung von Softwareprogrammen mit einer einfachen
grafischen Benutzeroberfläche, die folgende Möglichkeiten anbietet:
-
zur Datenmanipulation
-
zur Datenanalyse
-
zur grafischen Darstellung der Ergebnisse
-
und zur Speicherung von Daten und Ergebnissen
Vorteile von GNU R:
-
GNU R ist ein Klon der bekannten und sehr leistungsfähigen Programmiersprache S, die
in den Bell Labs von Chambers, Becker und Wilks entwickelt wurde.
-
Als Programmiersprache bietet „R“ ein komfortables, objektorientiertes Programmieren
an.
-
„R“ wird auf den Betriebssystemen LINUX, WINDOWS und Apple-Computer angeboten
und kann damit praktisch auf jedem PC und Großrechner eingesetzt werden. Zusätzlich
wird
„R“
noch
von
über
tausend
Softwarepaketen
für
die
verschiedenen
Aufgabenbereiche der Statistik, Informatik und Mathematik unterstützt.
-
Ein weiterer Pluspunkt besteht durch das Konzept der freien Benutzbarkeit von „R“ unter
der GPL (General Public License). Damit können Studenten, Schüler und Interessierte ein
professionelles System kostenlos nutzen.
12
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
-
Die Manuale und Hilfen von allen Paketen haben den gleichen Aufbau und die gleiche
dahinter stehende Logik. Dies erleichtert das Lesen von Hilfen und Manualen ungemein.
Tipp:
Auf der Seite von CRAN (http://www.cran.r-project.org/) kann man sich die
Software „R“ und Benutzerhandbücher für R herunterladen.
13
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
6.1
Voraussetzungen
Dieses Manual bezieht sich auf die folgende Hard- und Software.
Grundlegende Software
-
Windows XP (32 Bit) SP2 mit allen aktuellen Updates (Stand 09.08.2007)
-
Tinn-R 1.9.2.13. als externer Editor
-
„R“ 2.5.1 für Windows
-
„R“ 2.41 für Linux
-
IrfanView 4.0 & Adobe Photoshop CS2
-
VMWare 5.5.4 als virtuelle Umgebung
-
Ubuntu Linux 7.04 (Feisty Fawn)
Verwendete „R“ –Pakete
-
eRm (0.9.5)
-
R-Commander (1.3-5)
Hardware
-
Desktop – PC DuoCore (2 Kerne mit je 2,13 GHz) und 4 GB Hauptspeicher
-
Desktop – PC Intel DX4 (3 GHz) mit 768 MB Hauptspeicher
-
Notebook – Intel DX4 (3 GHz) mit 1 GB Hauptspeicher
Auf allen Systemen funktionierte „R“ einwandfrei. Es zeigte sich allerdings, dass eRm und
„R“ sehr rechenintensive Anwendungen sind und die Temperaturen verschiedener
Komponenten (z.B. Prozessor) erheblich steigen können. Leider kann die derzeit aktuelle
Version von „R“ 2.5.1 noch nicht die Möglichkeit von mehreren Prozessorkernen nutzen. Für
die Zukunft wäre dies wünschenswert.
Tipp: Weitere empfehlenswerte R-Pakete werden im Anhang beschrieben.
14
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
6.2
Plattformen für „R“
„R“ kann auf verschiedenen Plattformen verwendet werden. Allerdings muss man beachten,
dass es zwischen WINDOWS und LINUX gewisse Unterschiede gibt, die unter Umständen
große Auswirkungen haben können. Ein Problem besteht z.B. darin, dass es bei den
Textformaten Unterschiede gibt. Diese Unterschiede gipfeln darin, dass R-Code auf der
einen Seite unter WINDOWS einwandfrei läuft, auf der anderen Seite aber unter LINUX
Fehlermeldungen produziert. Um dieses Problem zu umgehen, muss man die WINDOWSDateien mit einem LINUX-Editor unter dem LINUX- Format speichern. Ein sehr guter Editor
zur Bearbeitung von Quellcode stellt
Programmiersprachen
GEDIT (unter LINUX) dar, der für verschiedene
Syntax-Highlighting
anbietet.
Werden
beim
Speichern
die
Einstellungen (UTF-8) im Menüpunkt „SPEICHERN UNTER“ verwendet, dann sollte es
auch keine Probleme mit Textdateien geben, falls R-Code unter LINUX eingelesen werden
soll. Ein weiteres Problem kann auftreten, wenn keine grafische Oberfläche unter LINUX
(KDE; GNOME) installiert ist. Dann hat der Benutzer nämlich nur Zeilenkommandos zur
Verfügung und kann nicht auf die Möglichkeiten der objektorientierten grafischen
Benutzeroberfläche zurückgreifen. Dieses Problem lässt sich unter LINUX einfach durch die
Installation von GNOME oder KDE lösen.
Tipp: Ein sehr guter, frei erhältlicher Editor für „R“ unter WINDOWS ist Tinn-R. Dieses
Programm arbeitet als externes Programm, verfügt aber über Möglichkeiten, um mit „R“
kommunizieren zu können. Außerdem kann in Tinn-R eine kleine Datenbank mit den
wichtigsten Funktionen von „R“ angesehen werden. Zusätzlich verfügt Tinn-R
selbstverständlich über Syntax - Highlighting für R.
Wichtig: Verwenden Sie zur Eingabe von größeren Befehlssequenzen ein externes
Programm (z.B. GEDIT (für Linux), Tinn-R (für Windows)). „R“ bietet nämlich keine
wirklich komfortablen Editierfunktionen zum Schreiben von Befehlssequenzen oder zum
Programmieren an. Wie der Name Tinn-R schon sagt, handelt es sich hier um einen Editor,
der speziell an „R“ angepasst wurde. Man kann sich dieses Programm unter
http://sourceforge.net/projects/tinn-r herunterladen. Tinn-R ist ein OpenSource-Programm,
das unter der GNU General Public License (GPL) läuft.
15
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
6.3
Die Installation von „R“ & eRm (unter WINDOWS)
Vorweg soll nochmals erwähnt werden, dass es sich hier um KEINE Einführung in „R“
handelt. Für eine grundlegende Einführung in „R“ werden Einführungsmanuale auf
http://www.cran.r-project.org/doc/manuals/
angeboten.
Zusätzlich
gibt
es
unter
http://de.wikibooks.org/wiki/GNU_R/ eine komplette Einführung in „R“. Hier findet man
auch viele zusätzliche Informationen und Hilfstexte zu „R“. In diesem Manual liegt der
Schwerpunkt allerdings auf der Einführung in „eRm – extended Rasch modeling“. Es geht
also um die Analyse und Prüfung des Rasch-Modells. Dabei werden exemplarisch Beispiele
gerechnet, Funktionen erklärt und in Screenshots genau gezeigt wie die Eingaben und die
Ausgaben aussehen.
Die Installation von „R“ ist sehr einfach und für die Systeme LINUX, MacOS und
WINDOWS möglich. Da die meisten Benutzer unter WINDOWS arbeiten, wird hier nur die
Installation unter WINDOWS XP beschrieben. Für die Installation von „R“ unter LINUX und
MacOS lesen Sie bitte das entsprechende Manual, das man sich auf der Website http://cran.rproject.org/ des CRAN (Comprehensive R Archive Network) unter dem Menüpunkt
Manuals kopieren kann.
Im ersten Schritt wird „R“ (unter WINDOWS) installiert. Dazu kopiert man sich die aktuelle
Version von „R“ von der Website des CRAN (Comprehensive R Archive Network). Man
geht dabei auf die Site http://cran.r-project.org/ und wählt dort den Menüpunkt „R_Binaries“
aus. Dort wählt man zuerst das „WINDOWS“ - Verzeichnis und dann das Verzeichnis „base“
aus. Wie der Name „base“ bereits andeutet, enthält dieses Verzeichnis die Basisinstallation
von „R“. Klicken Sie mit der linken Maustaste auf die Datei mit der Endung EXE und wählen
Sie im aufscheinenden Menü den Punkt „Ziel speichern unter“. Wählen Sie einen beliebigen
Ordner aus, merken Sie sich diesen Ordner und klicken Sie auf den Button „speichern“. Die
(ca. 29 MB große) Datei wird nun vom CRAN - Server auf den PC kopiert. Die aktuelle
Version zum Zeitpunkt des Verfassens dieses Manuals ist „R“ 2.5.1. Nachdem der
Kopiervorgang beendet ist, gehen Sie bitte in jenes Verzeichnis, in das die Installationsdatei
kopiert wurde, und starten Sie die Installation mit einem Doppelklick auf den Dateinamen.
Die Installation fängt an und man braucht nur mehr den Anweisungen des Programms zu
folgen.
16
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Im zweiten Schritt wird nun eRm installiert. Dazu starten Sie „R“ durch einen Doppelklick
auf das entsprechende Symbol auf dem Desktop oder wahlweise auch über Startmenü
Start/Alle Programme. Sie werden daraufhin von der spärlichen Benutzeroberfläche von
„R“ begrüßt (Abbildung 1).
Abbildung 1 – Begrüßung durch R
Um nun das Paket eRm zu installieren, müssen Sie im Menü „Pakete“ (Abbildung 2) den
Menüpunkt „Installiere Pakete“ auswählen.
Abbildung 2 - Auswahl des Menüpunkts "Installiere Pakete"
17
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Im folgenden Menüpunkt können Sie sich nun einen Server (Abbildung 3) aussuchen, von
dem Sie die gewünschten Pakete kopieren wollen. In unserem Fall wählen wir “Austria“
aus. (Dieser Server befindet sich derzeit am Department für Statistik und Mathematik an der
WU Wien.)
Abbildung 3 - Wahl des Servers (in diesem Fall Austria)
Wichtig: Wenn der Benutzer nur über eine langsame Internetverbindung verfügt, dann
sollten nur jene Pakete vom Server installiert werden, die auch tatsächlich gebraucht
werden. Auf dem Server befinden sich weit über 1000 Pakete und das Downloadvolumen
übersteigt bei weitem ein Gigabyte.
(1 Gigabyte = 1024 Megabytes = 1024x1024 Kilobytes = 1024*1024*1024 Bytes.)
„R“ öffnet und schließt nun ein paar Fenster (es werden die entsprechenden Informationen
aus dem Internet geladen) und bietet schließlich in einem Dialogfenster (Abbildung 4) die
Pakete an, die sich auf dem Server befinden. Die Sammlung von Paketen, die man über das
Internet installieren kann, ist beeindruckend und benötigt über 1 GB, wenn alle Pakete
installiert werden.
18
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 4 - Auswahl der gewünschten Pakete - in unserem Fall eRm
Suchen Sie dazu in der Paketliste das Package eRm und markieren Sie es. Dann klicken Sie
auf den Button „OK“. Das Paket wird installiert und im Anschluss wird „R“ aktualisiert.
Damit ist die Installation von „R“ und eRm beendet. Sollten weitere Pakete installiert werden,
dann gehen Sie wie oben beschrieben vor. Wollen Sie mehrere Pakete gleichzeitig
installieren, dann markieren Sie einfach die gewünschten Pakete. Die markierten Pakete
werden auf einmal installiert. Um mehrere Pakete zu markieren, müssen diese mit der linken
Maustaste und gleichzeitig gedrückter [STRG]-Taste ausgewählt werden. Nach der
Installation kann ein Paket sofort in den Speicher geladen werden und ist damit für die
Benutzung bereit.
Tipp:
Installieren Sie nur Pakete, die tatsächlich verwendet werden sollen. Wenn alle
Pakete (über 1000) installiert werden, dann kann (wie oben beschrieben) nicht nur der
Download sehr lange dauern, sondern es kann auch die Geschwindigkeit bei bestimmten
Operationen verlangsamt werden, weil „R“ sehr viele Dateien durcharbeiten muss. Wenn
man sich nur über die Pakete informieren will, kann man sich auf der Website
http://cran.r-project.org/ unter dem Menüpunkt „Packages“ kurze Beschreibungen über
das gewünschte Paket ansehen oder dessen Manual lesen.
19
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
6.4
Programmpakete laden
Um mit installierten Programmpaketen (z.B. eRm) arbeiten zu können, müssen diese zuerst
geladen werden. Dazu gibt es verschiedene Möglichkeiten. Eine Möglichkeit besteht darin
den Befehl library() zu verwenden. Man gibt folgende Sequenz in die Benutzeroberfläche
ein: libra
library(paketname).
Um beispielsweise das Paket „psy“ zu laden, geben Sie einfach library(psy) (Abbildung
5) ein. Wenige Sekunden später ist das Paket für die Benutzung bereit.
Abbildung 5 - das Paket „psy“ wurde geladen
Eine Liste mit allen installierten Paketen bekommt man mittels Eingabe von lib
library(). „R“
gibt daraufhin alle installierten Programmpakete aus. Eine zweite Möglichkeit Pakete zu
laden, besteht in der Auswahl des Menüpunktes „Pakete“. Im Untermenü muss noch der
Eintrag „Lade Paket“ (Abbildung 6) ausgewählt werden.
Abbildung 6 - Pakete laden über die GUI
20
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Daraufhin wird eine Liste mit Paketen angezeigt. Man wählt das gewünschte Paket aus, klickt
auf den OK-Button und das Paket wird geladen. In diesem Fall wurde das Paket „psy“
ausgewählt und wird durch Klicken auf den OK-Button geladen.
Abbildung 7 - Paket „psy“ wurde ausgewählt
Wichtig: „Installieren“ bedeutet nicht „laden“. Programmpakete, die bereits installiert sind,
müssen vor der Anwendung geladen werden und nicht installierte Programmpakete
müssen zuerst installiert werden, bevor sie geladen werden können.
21
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
6.5
Benutzeroberflächen unter „R“ für WINDOWS
Wenn die grafische Benutzeroberfläche (GUI = graphical user interface) von „R“ gestartet
wird, stellt sich für den Benutzer die Frage: „Was soll das?“. Man hat nämlich nur ein Fenster
mit wenigen Menübefehlen und noch weniger Inhalt am Bildschirm. Um diesen Zustand zu
beenden,
installiert
man
eine
grafische Hilfsoberfläche.
Die
Installation
solcher
Benutzeroberflächen soll in den nächsten Kapiteln (4.5.1, 4.5.2, 4.5.3) besprochen werden.
6.5.1 JGR („Java Gui for R“)
JGR heißt eigentlich „Java GUI for R“ und wird Jaguar (wie das Raubtier) ausgesprochen.
JGR ist ein interessantes AddOn zur grafischen Benutzeroberfläche von R, hat im Moment
aber noch nicht so viele Funktionen und kämpft mit Geschwindigkeitsproblemen. Die
Installation von JGR erfolgt wie es im vorhergehenden Kapitel 6.4 beschrieben wurde.
Außerdem muss von der Website http://www.rosuda.org/JGR/ auf der Downloadseite die
entsprechende EXE-Datei auf den PC kopiert werden. Derzeit ist JGR-15.exe die aktuelle
Datei. JGR wird mit einem einfachen Doppelklick auf die EXE–Datei ausgeführt. JGR startet
dann die Benutzeroberfläche von „R“ und bindet sich automatisch in die GUI ein.
Abbildung 8 – die R-Benutzeroberfläche mit integriertem JGR
22
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Eine sehr gute Funktion von JGR ist der object.browser() (siehe Abbildung 9), mit dem
man sich bequem über die Variablen und Objekte im Speicher von „R“ informieren kann.
Abbildung 9 - der Objektbrowser von JGR
Zudem bietet JGR eine hervorragende Unterstützung bei der Befehlseingabe (Abbildung
10), wie man sie von Visual Studio (Microsoft) und Netbeans (SUN) her kennt. So zeigt
JGR während des Tippens an, welche Werte an eine Funktion übergeben werden können.
Diese Funktion ist bei der Eingabe von Befehlssequenzen sehr hilfreich.
Abbildung 10 - Befehlseingabe unter JGR
23
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
6.5.2 Der R-Commander
R-Commander ist eine Benutzeroberfläche, die auf besondere grafische Raffinessen
verzichtet und dementsprechend schnell und handlich ist. R-Commander erinnert in seinem
Design an die Benutzeroberfläche von SPSS. Die meisten Benutzer werden mit dem RCommander gut zurechtkommen, weil er einfach zu bedienen ist.
Da der R-Commander im nächsten Kapitel verwendet wird, um Daten zu importieren, wird er
kurz beschrieben. Die Installation des R-Commander erfolgt über den Menüpunkt
Pakete/Installiere Pakete/ der R-Benutzeroberfläche. Bei der Installation ist es möglich, dass
sie die folgende Fehlermeldung (Abbildung 11) erhalten.
Abbildung 11 - der R-Commander benötigt weitere Pakete
Der R-Commander benötigt weitere Pakete. Damit das Installationsprogramm die
notwendigen Programmpakete installieren kann, muss der JA-Button (Abbildung 11)
gedrückt werden.
24
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 12 - Installation vom lokalen PC oder von einem CRAN - Server
Nachdem mit der linken Maustaste auf „JA“ geklickt worden ist, wird ein weiteres
Dialogfenster geöffnet (Abbildung 12) und das Installationsprogramm fragt, ob die Pakete
von einem CRAN-Server kopiert werden sollen. Da die meisten Benutzer die notwendigen
Pakete nicht auf dem lokalen PC haben, wählen wir CRAN aus und klicken auf OK. Es öffnet
sich ein weiteres Fenster, in dem der Server (bzw. das Land) ausgewählt werden muss. In
diesem Beispiel wurde „Austria“ gewählt. Nach einem weiteren Klick auf den OK-Button
werden die Pakete installiert. Nach der Installation kann der R-Commander mit
library(Rcmdr) in den Speicher geladen werden.
In Abbildung 13 sieht man, dass der R-Commander viele statistische Funktionen anbietet.
Selbstverständlich kann der R-Commander selbst keine statistischen Berechnungen
durchführen, er kann allerdings auf die vielen statistischen und mathematischen Funktionen
von „R“ zurückgreifen und diese in seine Benutzeroberfläche einbetten. Im Prinzip macht der
R-Commander dasselbe wie die Benutzeroberfläche von SPSS. Beide Programme
ermöglichen es dem Benutzer über eine GUI Syntaxbefehle an das zugrunde liegende
Rechenprogramm zu übergeben.
25
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 13 – das Statistikmenü der R-Commanders
Wie man anhand von Abbildung 14 sehen kann, haben R-Commander und „R“ verschiedene
Möglichkeiten der Grafikdarstellung. Sogar 3D-Grafiken können erstellt werden.
Abbildung 14 - das Grafikmenü des R-Commanders
26
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Im Menüpunkt Modelle (Abbildung 15) findet man Tests wie den Breusch-Pagan-Test auf
Heteroskedastiztität, den Durbin-Watson-Test auf Autokorrelation, den Bonferoni-AusreißerTest etc.
Abbildung 15 - weitere Hilfen des R-Commanders
Der R-Commander kann auch verschiedene Datenformate importieren (Abbildung 16). Der
Import von Daten wird im Kapitel 7.1 noch genauer behandelt.
Abbildung 16 - Datenimport mit dem R-Commander
Zusammenfassung: Der R-Commander ist eine große Hilfe für den Benutzer. Da eine
Beschreibung des Programmpakets „R-Commander“ dieses Handbuchs sprengen würde
und hier auch nicht das Thema ist, soll nur auf die Hilfe des R-Commanders verwiesen
werden. In diesem Hilfesystem gibt es unter anderem ein Manual namens „Einführung in
den R-Commander“.
27
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
6.5.3 Exkurs: Teaching Demos
Der R-Commander kann durch Plugins erweitert werden. Teaching Demos ist so ein Plugin
und bietet die Möglichkeit, statistische Vorgänge grafisch zu demonstrieren. Als erstes muss
dazu das entsprechende Plugin geladen werden (Abbildung 17).
Abbildung 17 – ein Plugin laden
Nachdem das Plugin „Teaching Demos“ geladen worden ist, muss der R-Commander neu
gestartet werden. Danach hat man einen weiteren Menüpunkt namens „Demos“ zur
Verfügung (Abbildung 18).
Abbildung 18 - Demonstrationen
28
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Nach der Auswahl von „Power of the test“ wird die folgende Demonstration (Abbildung 19)
gestartet.
Abbildung 19 - Power of the test
Der Benutzer kann in dieser Demonstration ausprobieren, welche Auswirkungen die
Manipulation der verschiedenen Variablen hat.
29
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
6.6
Objekte in „R“
„R“ arbeitet mit Objekten, die in Variablen gespeichert werden können. Solche Objekte
können mehr oder weniger komplex sein. Unter anderem gibt es folgende Objekte: array,
data.frame, factor, list, matrix, vector etc.
Vektoren werden mit dem Befehl c() gebildet und enthalten die entsprechenden Elemente,
die mit einem Komma-Zeichen voneinander getrennt werden: z.B. a=c(1,2,3) – damit
wird ein Vektor mit den Elementen 1, 2, 3 erstellt und in der Variablen a gespeichert.
-
Matrizen werden mit Hilfe des Befehls matrix(a,zeile,spalte) erstellt. a enthält
dabei die Daten, die in der Matrix gespeichert werden sollen. Mit „zeile“ und „spalte“
werden
die
Zeilenanzahl
und
die
Spaltenanzahl
angegeben.
Z.B.
matrix(c(1,2,3,4,5,6),3,2) erstellt eine Matrix mit drei Zeilen und zwei Spalten
(Abbildung 20).
Abbildung 20 - ein Objekt vom Typ Matrix wird erstellt
Zeilenanzahl und Spaltenanzahl (die Dimensionen der Matrix) können mit dem Befehl
dim() abgefragt werden.
-
Faktoren sind Objekte, die kategorielle Daten enthalten.
-
Arrays sind einfache Datenfelder, die mit dem Befehl array() erstellt werden. Dabei
wird ein Vektor an die Funktion array() übergeben. In Abbildung 21 wird ein Vektor
mit der Funktion c() erstellt und in der Variablen a gespeichert. Im nächsten Schritt wird
dieser Vektor an die Funktion array() übergeben. Es wird ein Array mit den Werten
von Variable a erstellt und in Variable b gespeichert. Die Funktion is.array()
überprüft, ob es sich bei einem Objekt um ein Array handelt und gibt TRUE oder FALSE
zurück. In unserem Beispiel wird bei der Variablen a FALSE zurückgegeben, da es sich
um einen Vektor handelt (Abbildung 21). Bei Variable b, die tatsächlich ein Array ist,
wird TRUE zurückgegeben. Auf die Elemente eines Arrays kann man zugreifen, indem
30
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
der Name des Arrays und der Index des Elements angegeben werden. Der Index muss in
eckigen Klammern stehen. Mit b[2] wird zum Beispiel der Wert des zweiten Elements
von b zurückgegeben. In unserem Beispiel ist das 10.
Abbildung 21 - ein Array wird erstellt
-
Dataframes sind komplexe Strukturen und werden nicht weiter besprochen.
-
Listen sind die wohl mächtigsten Strukturen in „R“ und eine Liste kann sehr
komplexe Strukturen beinhalten. Auch Listen werden nicht weiter besprochen.
Während also Objekte vom Typ matrix, vector, array und factor relativ einfach aufgebaut
sind, können die Objekte list() und data.frame() eine Vielzahl von anderen Objekten
beinhalten. Sie eigenen sich damit hervorragend zur Speicherung von komplexen
Ergebnissen. Auch eRm verwendet list()-Objekte zur Ergebnisspeicherung. Wichtige eRmObjekte sind das Rm-Objekt, das LLTM-Objekt, das LR-Objekt, das Wald-Objekt etc. Einen
Überblick über die Objekte von eRm gibt Kapitel 10.
Wichtig: Die Objekte list() und data.frame() können sehr komplex sein und brauchen viele
Ressourcen (z.B. Speicher). Eine Konsequenz kann dann eine erhöhte Rechendauer sein.
31
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
6.7
Wichtige Befehle für „R“
Um „R“ in kurzer Zeit kennen zu lernen, lesen Sie bitte eine der vielen Einführungen, die
bereits vorhanden sind. Diese Einführungen dauern nicht länger als eine Stunde, geben aber
einen guten Einblick in „R“. In diesem Kapitel werden die wichtigsten „R“-Befehle erwähnt,
die für dieses Manual wesentlich sind.
Wichtig: Achtung, „R“ unterscheidet strikt zwischen Groß– und Kleinschreibung. Identische
Befehle, die sich nur in der Großschreibung unterscheiden, können völlig unterschiedliche
Bedeutungen haben.
help() … der wichtigste Befehl in „R“ ist der Befehl help(). Mit ihm wird es
möglich, Informationen und Hilfen zu „R“ und zu den Programmpaketen aufzurufen.
Wird help() alleine aufgerufen erhält man eine Übersicht über die Befehle von „R“.
Wird help(Befehl) aufgerufen, dann erhält man eine Hilfe zu dem eingegebenen
Befehl. z.B.: help(str). Nachdem die Befehlssequenz mit der [RETURN]-Taste
abgeschlossen wurde, werden Informationen zu str() ausgegeben. Die Hilfe ist unter
„R“ sehr standardisiert. Am Anfang wird immer der Befehl mit seinen Optionen
beschrieben. Dann werden die verschiedenen Befehlsvarianten beschrieben. Am Ende
der Hilfe findet man oft hilfreiche Beispiele. Die Möglichkeiten von help() sind
zahlreich und können in Skripten zu „R“ nachgelesen werden. Der help()-Befehl
funktioniert nur bei geladenen Programmpaketen und für das „R“-Basispaket
allgemein.
help.search(„BEGRIFF“) … mit diesem Befehl können sämtliche
Hilfedateien (inklusive der Hilfedateien von allen installierten Programmpaketen)
nach Begriffen durchsucht werden.
fix(name) … mit diesem Befehl kann ein Objekt, z.B. eine Matrix, betrachtet oder
manipuliert werden. Außerdem kann man mit diesem Befehl eigene Funktionen
schreiben. Allerdings sind die Editierfunktionen sehr eingeschränkt. Es wird hier
ausdrücklich davon abgeraten, Funktionen mit Hilfe von fix() zu programmieren.
32
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
data() … damit kann man Datenpakete laden, die von den Programmierern der
Softwarepakete mitgeliefert wurden. Zusätzlich kann man mit data() einen schnellen
Überblick gewinnen, welche Datenpakete verfügbar sind.
? ... mit dem Fragezeichen kann auch die Hilfe aufgerufen werden; dazu gibt man
einfach ?summary ein. Auch das Fragezeichen ? funktioniert nur bei geladenen
Programmpaketen.
str() ... damit werden die internen Strukturen eines Objektes ausgegeben. Dieser
Befehl wird im Kapitel eRm noch eingehender behandelt.
summary() … gibt eine Zusammenfassung aus. Diese Methode wird sehr oft von
Programmpaketen (z.B. eRm) verwendet und dabei an das Paket angepasst.
library(paket1) ... das Softwarepaket paket1 wird geladen. Wird nur library()
eingegeben, dann werden alle installierten Programmpakete aufgelistet.
ls() ... alle Objekte/Variablen werden am Bildschirm ausgegeben.
print() ... eine Variable wird ausgegeben.
write(a,fname) … mit dem Befehl write() können Daten in externe Dateien
geschrieben werden. Dabei wird der Inhalt von Objekt a in die Datei „fname“
geschrieben. Unterbefehle von write() sind unter anderem write.csv (damit
können Daten in CSV-Dateien gespeichert werden) und write.table (die Daten werden
in eine Tabelle geschrieben).
quit() oder q()… mit dem Befehl quit() kann „R“ beendet werden; alternativ kann
man auch aus dem Menü „Datei“ den Befehl „Beenden“ auswählen.
33
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
A
<- B … der Pfeil dient in „R“ als Zuweisungsoperator. Dabei wird immer der
Inhalt der rechts vom Pfeil stehenden Variablen in die links vom Pfeil stehende
<- 7). Damit wird der Variable myvar der
Variable geschrieben. (z.B. myvar
Wert 7 zugeordnet.
A = B … das Gleichheitszeichen „=“ dient in „R“ als zusätzlicher
Zuweisungsoperator und ist damit eine Alternative für den Pfeil „<-“ als
Zuweisungsoperator. Von der Historie und der Sprachlogik her wird allerdings die
Verwendung des Pfeils empfohlen.
Eigene Notizen:
34
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
6.8
Rechnen mit „R“
„R“ ist auch ohne Erweiterungen durch Programmpakete ein sehr umfangreiches
Statistikprogramm. Für eine erfolgreiche Benutzung muss man kein Programmierer sein. Um
Berechnungen durchzuführen, gibt man Werte und Operationen ein und schließt die Eingabe
mit der [RETURN]-Taste ab. In Abbildung 22 wurde beispielsweise 100! berechnet.
Abbildung 22 - Berechnung der Faktoriellen
„R“ verfügt zudem über verschiedene Möglichkeiten der grafischen Ausgabe. Da eine
Einführung in die Grafikmöglichkeiten den Umfang dieses Handbuchs sprengen würde, wird
der interessierte Leser darauf hingewiesen, dass man sich von der CRAN - Homepage ein
Manual über den Einsatz von Grafiken in „R“ kopieren kann. Die grafischen Möglichkeiten
sind der große Pluspunkt von „R“ gegenüber den anderen Statistikprogrammen.
Beispiel/Code:
x=seq(x=seq(-pi,pi,0.1)
plot(sin(x))
In dieser Codesequenz wurde eine Variable x erstellt. Variable x enthält die Werte von –Pi bis
Pi, wobei die Werte immer um 0.1 erhöht werden. Im zweiten Schritt werden die Werte von x
an die Funktion sin(x) geschickt, die ihrerseits die berechneten Werte an die Funktion
plot() übergibt. Das Ergebnis obigen Befehls steht in Abbildung 23.
35
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 23 - Darstellung einer Sinuskurve
Ein weiteres Beispiel ist die Erstellung von gleichverteilten Zufallszahlen. „R“ verfügt über
verschiedene Funktionen, um Pseudozufallszahlen zu generieren. Mit der Funktion runif()
können gleichverteilte Pseudozufallszahlen erzeugt werden. Mit der Funktion rnorm()
können normalverteilte Pseudozufallszahlen erzeugt werden. In Abbildung 24 wurden 50
Realisationen einer gleichverteilten Zufallsvariable gezogen. Die Zufallszahlen nehmen
Werte zwischen 1 und 6 an
.
Abbildung 24 - Würfelsimulation
Tipp: Mit „R“ werden selbstverständlich keine echten Zufallszahlen generiert, sondern es
werden sogenannte Pseudozufallszahlen erzeugt. „R“ verwendet sehr gute ZufallszahlenAlgorithmen wie den Mersenne-Twister–Algorithmus. Weitere Informationen zum
verwendeten Zufallszahlengenerator bekommt man mit help(RNG). Zusätzlich gibt es
noch weitere Pakete mit Pseudozufallszahlengeneratoren (PRNGs). Das Paket random
ermöglicht sogar den Import von angeblich echten Zufallszahlen.
36
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Mit dem Befehl scatter3d (Abbildung 25) können 3D-Grafiken erstellt werden. Der
Befehl scat
scatter3d() stammt aus dem Softwarepaket „Rcmdr“ (R-Commander).
Abbildung 25 - Befehl für eine 3D-Ausgabe
Das Ergebnis des Befehls scatter3d()
scatter3d() ist in Abbildung 26 zu sehen.
Abbildung 26 - Darstellung einer 3D-Grafik
In dieser Befehlssequenz wird Variable x mit den Sinuswerten von 1 bis 100 gefüllt. Die
Variable y wird mit den Kosinus-Werten von 1 bis 100 gefüllt. Variable z enthält das Produkt
von x*y. Die Bildschirmdarstellung von scatter3d() ist in Abbildung 28 zu sehen.
Abbildung 27 - Befehl zu einer weiteren 3D-Darstellung
37
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 28 - 3D-Darstellung von Sinus und Kosinuswerten
Ein letztes grafisches Beispiel gibt es in Abbildung 29 zu sehen.
Beispiel/Code:
scatter3d(x,sin(x),cos(y),xlab="dritteAchse",ylab="erste Ach
Achse",
zlab="zweite Achse", surface.col="blue", surface=T, fill=T,
fog
fogtype="exp")
type="exp")
Abbildung 29 - ein weiteres 3D-Beispiel
38
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Tipp: Ein sehr gutes Buch zum Umgang mit Grafiken in „R“ ist „R Graphics“ von Paul
Murrell erschienen im Verlag Chapman & Hall/CRC.
Im letzten Beispiel (Abbildung 30) wird mittels Monte-Carlo-Simulation die Zahl Pi
berechnet. Dazu wird eine kleine Funktion erstellt. An diese Funktion wird die Anzahl der
verwendeten Zufallszahlen übergeben. Die Zufallszahlen stammen aus der Gleichverteilung
und haben Werte zwischen 0 und 1. Je größer n gewählt wird, desto besser ist die Annäherung
an die Zahl Pi.
Abbildung 30 - Berechnung von Pi nach der Monte Carlo - Methode
Nachdem in diesem Kapitel die Möglichkeiten von „R“ als Taschenrechner gezeigt wurden,
gibt es im nächsten Kapitel einen Überblick über „R“-Programmpakete im Bereich der
probabilistischen Testtheorie.
Zusammenfassung:
Die Funktionen plot(), scatter3d() und scatterplot3d() sind Hilfsmittel zur
grafischen Darstellung von Funktionen. Der Befehl plot() ist ein Basisbefehl von R und
muss nicht geladen werden. scatter3d() ist ein ein Teil des R-Commander.
scatterplot3d() ist ein Befehl des gleichnamigen Pakets.
39
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
6.9
„R“-Software-Pakete im Bereich der IRT
Im Moment werden für „R“ folgende Pakete im Bereich der IRT angeboten.
-
eRm (Mair, Patrick & Hatzinger, Reinhold) - Schätzung von Modellen über die
bedingte Maximum-Likelihood-Methode
-
ltm (Rizopoulos, Dimitris) – Schätzung von Modellen über die Marginal Maximum –
Likelihood-Methode
-
irtoys (Partchev, Ivailo) – Schnittstelle zu Programmen wie ICL, BILOG, ltm
-
mlIRT (Fox, John) – beschäftigt sich mit Multi–Level–Modellen
-
mokken(van der Ark, L. Andries) – Funktionen für die Analyse von Mokken-Skalen
-
MiscPsycho (Doran, Harold) – Schätzung von Rasch-Modellen über die Joint –
Maximum Likelihood – Methode
40
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
7 Daten austauschen
7.1
Der Datenimport
Dieses Kapitel zeigt, wie Daten in „R“ importiert werden können. Einerseits geht das mit
Syntaxbefehlen. Vor allem aber für Anfänger empfiehlt sich der R-Commander. Im
Folgenden wird mittels R-Commander gezeigt, wie Daten aus verschiedenen Datenquellen
importiert werden können. Als Beispiel zeigen wir dies mit einer SPSS-Datei. Bevor wir mit
dem Import der Daten ins „R“ beginnen können, muss der R-Commander geladen werden.
Dies geschieht mit folgendem Befehl: libra
library(Rcmdr)
ry(Rcmdr
Abbildung 31 - R-Commander laden
Der R-Commander wird geladen und automatisch gestartet. Nach dem Start erhalten wir das
Bild in Abbildung 32.
Abbildung 32 - der R-Commander ist einsatzbereit
41
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Tipp: Wenn Sie den R-Commander aus welchen Gründen auch immer beenden, können Sie
ihn später mit dem Befehl Commander() wieder starten.
Da Daten nach „R“ importiert werden sollen, ist hier der Menüpunkt Datenmanagement
von Interesse. Hinter diesem Menüpunkt verstecken sich die Import-Möglichkeiten für
verschiedene Dateiformate (Abbildung 33).
Abbildung 33 - Möglichkeiten des Datenimports
Diese Formate sind normale Textdateien (die Dateien können dabei verschiedene
Trennsymbole haben wie Komma und Strichpunkt), SPSS - Dateien (viele Anwender werden
ihre Daten aus SPSS ins „R“ importieren wollen), Mini-Tab-Dateien (diese Möglichkeit des
Imports wird wohl weniger verwendet werden) und Stata–Datendateien. Schließlich können
auch Datenbanken und Excel-Dateien über einen entsprechenden Treiber ins „R“ importiert
werden. Ein weiteres interessantes Merkmal stellt der Import von Daten direkt aus der
Zwischenablage dar.
Info: Der Fachausdruck für Trennsymbole ist „Delimiter“.
Tipp: Wollen Sie tatsächlich Excel-Dateien ins „R“ importieren, dann verwenden Sie das
Package (xlsReadWrite). Von diesem Package gibt es eine Normalversion (gratis) und eine
Profi-Version (kommerziell). Für fast alle Zwecke reicht die Standardversion aus. Mit
diesem Package können Excel-Dateien sauber ins „R“ importiert werden.
42
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Es wird nun eine SPSS-Datei über den Menüpunkt Datenmanagement/Importiere
Daten/ aus SPSS-Datendatei importiert (siehe Abbildung 34).
Abbildung 34 - eine SPSS - Datei soll importiert werden
Dazu wählen wir den Unterpunkt aus SPSS Datendatei und gelangen zu dem
Dialogfenster in Abbildung 35.
Abbildung 35 - Import einer SPSS - Datendatei
Das Dialogfenster (Abbildung 35) bietet folgende Möglichkeiten:
-
Angabe eines Namens für die Datenmatrix (der Name der Datenmatrix ist der Name,
mit dem wir unsere Datenmatrix unter „R“ oder dem R-Commander aufrufen können)
-
Konvertierung der Werteetiketten zu Faktorstufen
43
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
-
Angabe der maximalen Anzahl der Werteetiketten für die Umwandlung
Standardmäßig konvertiert „R“ die Werteetiketten beim Importieren und man kann unendlich
viele Werteetiketten verwenden. Bei der Namenswahl der Datenmatrix sollte man einen
kurzen Namen verwenden, der aber trotzdem informativ ist. Unter Umständen müssen Sie
den Namen der Datenmatrix sehr oft schreiben.
Wichtig: Werteetiketten sind ein unglücklicher Name, der wohl seinen Ursprung in einer
allzu wörtlichen Übersetzung vom Englischen ins Deutsche hat. Der Name Label wurde
hier nämlich sehr unzutreffend mit Etikette übersetzt. Das stimmt im Prinzip, aber „label“
heißt im Deutschen auch Beschriftung und Name. Und diese beiden Begriffe sind dann
auch sinnvoller als Etikette. Man gibt ja schließlich Namen für die entsprechenden Werte
an. Als Beispiel kann man an das Geschlecht denken. Hier haben wir die Werte 1 und 2.
Diese beiden Werte haben dann die Namen Mann und Frau. SPSS bezeichnet die „value
labels“ im Deutschen ganz einfach mit Wertelabels. Das ist auch kein schöner Begriff, aber
er verwirrt weniger als das Wort „Werteetikette“.
44
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 36 - Auswahl der Datendatei, die importiert werden soll
Nachdem wir auf den „OK-Button gedrückt haben, kommen wir zu einem DateidialogFenster, in dem wir die Datei suchen müssen, die importiert werden soll. In Abbildung 36
können Sie sehen, dass die Datei bereits gefunden wurde. Nachdem die Datei markiert wurde,
kann man sie mit einem Klick auf den Button „Öffnen“ nach „R“ importieren. Damit wurde
eine erste Datei des kommerziellen SPSS in das OpenSource - Programm „R“ importiert. Wir
wechseln nun zum R-Commander und sehen, dass im Skript und im Ausgabefenster eine
Befehlssequenz steht. Diese Befehlsequenz haben wir gerade mit dem R-Commander erstellt.
Im Skriptfenster des R-Commanders können Sie auch Befehle direkt eingeben. Ausgeführt
werden die Befehle, wenn Sie auf den Button „Befehl ausführen“ klicken (siehe Abbildung
37).
45
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 37 –Import der SPSS-Datendatei mittels „read.spss“
Nachdem wir eine Datei nach „R“ importiert haben, wollen wir nun überprüfen, ob dieser
Vorgang auch korrekt durchgeführt wurde. Zur Überprüfung werden die beiden Buttons
„Datenmatrix bearbeiten“ und „Datenmatrix betrachten“ verwendet, die sich knapp unterhalb
der Menüleiste befinden. Mit letzterem Befehl können wir nur die Datenmatrix betrachten.
Das ist nicht sehr zweckmäßig. Aus diesem Grund drücken wir auf den Button „Datenmatrix
bearbeiten“ drücken (Abbildung 38).
Abbildung 38 - die Buttons "Datenmatrix bearbeiten" & "Datenmatrix betrachten"
Auf ihrem Bildschirm sollte dann eine Datenmatrix ähnlich Abbildung 39 dargestellt werden.
Abbildung 39 – eine Datenmatrix
46
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Das markierte Feld (Abbildung 39, Spalte V1, Zeile 1) ist zu diesem Zeitpunkt ausgewählt
und kann deshalb verändert werden. Der Dateneditor ist nur ein einfacher Editor mit wenigen
Mitteln, um Datenmatrizen zu manipulieren.
Zur weiteren Information: Der Button „Datenmatrix bearbeiten“ entspricht genau dem
Befehl fix(). Genauer gesagt, wenn der Button „Datenmatrix bearbeiten“ angeklickt wird,
dann wird der Befehl fix() ausgeführt. Bei kurzen Befehlssequenzen ist es sinnvoll, den
Code direkt ins „R“ einzutippen.
Wichtig: Die Konvertierung von der Struktur Liste in die
Wichtig: Eine Liste in „R“ darf nicht mit einer normalen Liste verwechselt werden, wie man
sie von Programmiersprachen wie LISP oder JAVA her kennt. Eine Liste in „R“ ist ein viel
komplexeres Gebilde und kann große Datenmengen speichern. Eine Liste ist ein mächtiges
Objekt und kann sehr viele Ressourcen benötigen.
Wir beenden nun den R-Commander mit dem Menübefehl „Datei/Beenden/des
Commanders“. Damit wird nur der R-Commander beendet. Wird der Befehl
„Beenden/des Commanders und Rs“ ausgewählt, dann wird auch „R“ beendet
(Abbildung 40).
Abbildung 40 - R-Commander beenden
Der Import der Datenmatrix ist damit abgeschlossen. Mit dem Befehl is.xxx() kann man
nun überprüfen, ob ein Objekt von einem bestimmten Typ ist. Mit is.matrix(d) kann
47
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
überprüft werden, ob d eine Matrix ist. Da in diesem Fall ein FALSE als Ergebnis
zurückgeliefert wird, ist die d also eine einfache Matrix (siehe Abbildung 41).
Abbildung 41 - die Datenmatrix d ist keine Matrix
Als nächstes wird mit is.list(d) geprüft, ob es sich bei d um eine Liste handelt (Abbildung
42). Als Ergebnis wird ein TRUE zurückgegeben und wir wissen damit, dass d ein Objekt
vom Typ Liste ist.
Abbildung 42 - die Datenmatrix d ist eine Liste
Um eine Struktur zu konvertieren (in diesem Fall wollen wir eine Liste in eine Matrix
umwandeln), braucht man den Befehl as und den Namen der Struktur. Mit der
Befehlssequenz „d=as.matrix(d)“ kann d in eine echte Matrix konvertiert werden. Die
Konvertierung von einer Liste in eine Matrix hat aber einen Nachteil. Der R-Commander
kann mit einfachen Matrizen nicht arbeiten.
Nachdem wir nun wissen, wie wir Daten importieren können, müssen die Dateien auch
wieder gespeichert werden. Dazu gibt es zwei Möglichkeiten. Man kann die Daten in eine
externe Datei exportieren oder man speichert die Daten mit Hilfe eines Workspace. Diese
beiden Möglichkeiten werden in den nächsten beiden Kapiteln besprochen.
48
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
7.2
Der Datenexport – der write()-Befehl
Daten brauchen nur dann extern gespeichert werden, wenn sie anderen Programmen (z.B.
Excel, SPSS) zur Verfügung gestellt werden sollen. Für die Speicherung von Daten innerhalb
von „R“ gibt es die Möglichkeit, alle Daten mit der Menüoption „Datei/Sichere
Workspace“ auf einmal zu speichern.
Mit dem Befehl write() wird dem Benutzer die Möglichkeit geboten, seine Daten in
externen Dateien zu speichern. Mit dem Befehl write(a,“info.txt“) werden die Daten in
Variable a in die Datei „info.txt“ geschrieben. Dies ist die einfachste Version des Befehls
write() und das Ergebnis der Datensicherung ist nicht immer erwünscht.
Mit write.table(data, „c:\
„c:\\patrick\
patrick\\mydata.csv“, sep=“;“) wird eine
Tabelle namens „data“ in eine externe Datei mit dem Namen „mydata.csv“ geschrieben.
Dabei wird als Trennsymbol der Strichpunkt genommen. Außerdem wird die Datei ins
Verzeichnis „patrick“ geschrieben. Der Befehl write.table() bietet viele Optionen an und die
Hilfe zu diesem Befehl ist sehr nützlich.
Mit write.csv(data, „c:\
„c:\\daten\
daten\\mydata.csv“) werden Daten in die Datei
mydata.csv geschrieben, die sich im Verzeichnis „c:\\daten“ befindet. Dabei wird das Komma
„,“ als Trennsymbol und der Punkt „.“ als Dezimalpunkt verwendet. Das CSV-Format ist ein
einfaches Textformat und eignet sich sehr gut für den Export, da es von fast allen
Programmen erkannt wird. CSV steht für „commata separated values“.
Mit write.csv2(data, „c:\
„c:\\daten\
daten\\mydata.csv“) werden ebenfalls Daten in die
Datei mydata.csv geschrieben, die sich im Verzeichnis „c:\\daten“ befindet. Dabei werden
allerdings der Strichpunkt „;“ als Trennsymbol und das Komma „,“ als Dezimalpunkt
verwendet. CSV2-Dateien sind an die deutschsprachige Excel-Version angepasst, die das
Komma als Dezimalpunkt verwendet.
49
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Zusätzlich zum einfachen write()-Befehl bietet das „R“-Paket foreign noch zusätzliche
Möglichkeiten zum Lesen und Schreiben von Dateien. So kann man mit diesem Package z.B.
Dbase – Dateien (.dbf) erstellen.
Sollten Daten in Excel-Tabellen (*.xls) gespeichert werden, eignet sich das Package
xlsReadWrite mit den Befehlen write.xls und read.xls sehr gut zur Speicherung.
Eigene Notizen:
50
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
7.3
Workspace – eine Möglichkeit zur Datenspeicherung
Ein Workspace (Arbeitsplatz) ist eine Möglichkeit, um komplette Projekte zu managen. Der
Vorteil von einem Arbeitsplatz ist seine Fähigkeit, mehrere Objekte auf einmal im Speicher
halten und verwalten zu können. Diese Objekte können Ergebnisse, Grafiken, Funktionen etc.
sein. Wird ein Arbeitsplatz mit „Datei/Sichere Workspace“ gespeichert, dann werden
automatisch alle im Workspace enthaltenen Objekte gespeichert. Wird der Workspace wieder
geladen, werden automatisch auch alle Objekte geladen. Dies ist die effizienteste Art der
Datenspeicherung unter „R“. Um einen Workspace zu speichern, klickt man auf das Menü
„Datei/Sichere Workspace“ (Abbildung 43).
Abbildung 43 – Sichere Workspace
Auf dem Bildschirm öffnet sich ein Datei-Dialogfenster (Abbildung 44). Nun muss man ein
Verzeichnis und einen Dateinamen für den Workspace auswählen. Die Endung .RData steht
für einen Workspace und sollte nicht geändert werden. Nachdem man sich ein Verzeichnis
ausgesucht hat und den Namen eingegeben hat, klickt man auf Speichern.
51
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 44 – Datei zum Speichern auswählen
Geladen wird ein Workspace, indem man im Menü „Datei/Lade Workspace“ (Abbildung 45)
auswählt.
Abbildung 45 – Lade Workspace
Im nun erscheinenden Dialogfenster (Abbildung 46) muss man das Verzeichnis und die
gespeicherte Workspace - Datei auswählen. Anschließend klickt man auf „Öffnen“ und der
Workspace wird geladen. Damit ist der Ladevorgang abgeschlossen.
52
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 46 – Datei auswählen
Tipp:
Der Workspace ist eine sehr effiziente und einfache Möglichkeit zum Verwalten von
Objekten und Projekten.
53
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
8 extended Rasch modeling eRm
Bevor auf das Paket „eRm – extended Rasch Modeling“ eingegangen wird, wird dem
Anfänger und interessierten Laien empfohlen, sich eine entsprechende Literatur für die
Einarbeitung in die Theorie zu besorgen.
Bücher, die für eine Einführung in die Praxis und Theorie des Rasch-Modells geeignet sind
Bond, T., & Fox, C. (2001). Applying the Rasch model: Fundamental measurement in the
human sciences. Mahwah, NJ: Lawrence Erlbaum Associates, Inc.
Baker, F. B., & Kim, S. (2004). Item Response Theory: Parameter Estimation Techniques.
(2nd ed.). New York: Dekker.
Fischer, G. H. (1974). Einführung in die Theorie psychologischer Tests [Introduction to
Mental Test Theory]. Huber, Bern.
Kubinger, K.D. (1989). Aktueller Stand und kritische Würdigung der probabilistischen
Testtheorie. In K.D. Kubinger (Hrsg.), Moderne Testtheorie - Ein Abriß samt neuesten
Beiträgen (S. 19-83), (2. Aufl.). München: Psychologie Verlags Union.
Kubinger, K.D. (2003). Skalierung. In K.D. Kubinger & R.S. Jäger (Hrsg.), Schlüsselbegriffe
der Psychologischen Diagnostik (S. 387-390). Weinheim: Beltz/PVU.
Rasch, G. (1960). Probabilistic models for some intelligence and attainment tests.
Copenhagen: Danish Institute for Educational Research.
Rost, J. (2004). Lehrbuch Testtheorie - Testkonstruktion. (2. Aufl.). Bern: Huber.
Für ein erstes Arbeiten mit eRm werden keine besonderen Kenntnisse vorausgesetzt, wobei
natürlich gute Kenntnisse des Rasch-Modells von Vorteil sind.
54
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
8.1
eRm - extended Rasch modeling (Mair & Hatzinger, 2006)
eRm ist ein Programmpaket für „R“, das anhand der bedingten Maximum-LikelihoodSchätzung (CML = conditional maximum likelihood) verschiedene Modelle aus der Familie
des Rasch-Modells analysiert.
Das dichotome logistische Raschmodell ist das einfachste Modell. Das LPCM ist das
komplexeste Modell. Jedes andere Modell kann durch ein LPCM gebildet werden.
eRm kann folgende Modelle über die bedingte Maximum-Likelihood-Schätzung
analysieren
-
das dichotome logistische Rasch-Modell (RM) (Rasch, 1960)- das einfache
dichotome, logistische Rasch-Modell mit einem Parameter – die Analyse dieses Modells
mit eRm wird in diesem Kapitel ausführlich behandelt
-
das linear-logistische Test-Modell (LLTM) (Scheiblechner, 1972 & Fischer, 1973) linear
logistic
test
model
–
das
lineare
logistische
Testmodell
und
seine
Anwendungsmöglichkeiten werden in diesem Manual nicht besprochen. Es ist allerdings
für spätere Versionen geplant, auch das LLTM zu besprechen.
-
das Ratingskalen-Modell (RSM) (Andrich, 1978)
-
das partial-credit Modell (PCM ) (Masters, 1982)
-
das lineare Ratingskalen–Modell (LRSM) (Fischer & Parzer, 1991)
-
das lineare partial-credit Modell (LPCM) (Fischer & Ponocny, 1994) – das lineare
partial-credit Modell ist das allgemeinste Modell in der Familie der Rasch-Modelle und
alle anderen Modelle können durch das LPCM dargestellt werden.
Da das einfache, dichotome Rasch-Modell das wichtigste Modell ist, wird dieses Modell
besprochen. Die Modelle LLTM, RSM, PCM, LRSM und LPCM werden in der ersten
55
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Version des Handbuchs nicht besprochen, für zukünftige Versionen ist allerdings geplant,
auch diese Modelle zu behandeln.
eRm verfügt über folgende Befehle zur Rasch-Modell-Analyse:
− RM() – Datenanalyse nach dem einfachen Rasch-Modell
− LLTM() – Datenanalyse nach dem linear-logistischen Test-Modell
− RSM() – Datenanalyse nach dem Ratingskalen-Modell
− PCM() – Datenanalyse nach dem partial-credit Modell
− LRSM() – Datenanalyse nach dem linearen Ratingskalen-Modell
− LPCM() – Datenanalyse nach dem linearen partial-credit Modell
Das eRm bietet neben Modellschätzungen noch folgende Möglichkeiten an
-
Schätzung der Personenparameter (siehe Kapitel 8.5.1)
-
Überprüfung des Modells nach dem bedingten Likelihood-Quotiententest (Andersen,
1973) (siehe Kapitel 8.5.2)
56
-
Überprüfung des Modells mittels Grafischem Modelltest (siehe Kapitel 8.5.3)
-
Überprüfung der Items mittels Waldtest (siehe Kapitel 8.5.4)
-
Berechnung von Personfit und Itemfit – Statistiken (siehe Kapitel 8.5.5)
-
Berechnung der Informationsindices (siehe Kapitel 8.5.6)
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
8.2
Die Analyse eines Rasch-Modells (RM)
Abbildung 47 - Formel des dichotomen, logistischen Rasch-Modells
Da es sich beim Programmpaket eRm um ein spezielles Paket zur Analyse von RaschModellen handelt, wird hier davon ausgegangen, dass der Leser bereits theoretische
Kenntnisse über das Rasch-Modell hat. Sollte dies nicht der Fall sein, gibt es verschiedene
Bücher, die für einen Einstieg in die IRT gut geeignet sind. Aus diesem Grund wird hier auf
eine Einführung verzichtet. Für einen Einblick hinter die Theorie von eRm eignen sich
besonders die folgenden Artikel:
− Mair, P., & Hatzinger, R. (2007). Extended Rasch modeling: The eRm package for the
application of IRT Models in R. Journal of Statistical Software, 20, 9.
URL http://www.jstatsoft.org/v20/i09/.
− Mair, P., & Hatzinger, R. (2007). CML based estimation of extended Rasch models
with the eRm package in “R”. Psychology Science, 49, 26-43.
Bevor die Arbeit mit eRm beginnen kann, muss im ersten Schritt eRm geladen werden. Dazu
gibt man folgendes ein: library(eRm)
Nach wenigen Sekunden sollte das eRm - Programmpaket geladen sein (Abbildung 48) und es
wird folgende Nachricht ausgegeben:
Abbildung 48 – eRm wurde geladen
57
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Für die Berechnungen werden Daten benötigt. Wenn eigene Datenmatrizen verwendet
werden sollen, kann man so vorgehen, wie es im vorigen Kapitel beschrieben wurde - man
lädt den R-Commander und importiert die Daten. In diesem Beispiel wurde von den Autoren
bereits eine kleine CSV-Datei vorbereitet. Stehen keine Daten zur Verfügung, kann man sich
vom Arbeitsbereich Psychologische Diagnostik der Fakultät für Psychologie eine
entsprechende Datenmatrix von der Homepage www.univie.ac.at/psychologie/diagnostik
kopieren.
Nach dem erfolgreichen Datenimport wird eine erste Rasch-Modell-Analyse durchgeführt.
Dazu wird folgende Befehlssequenz in die R-GUI eingegeben(siehe Abbildung 49)
RM(mat1)
Zur weiteren Information:
CSV-Dateien haben den Vorteil, dass sie sehr einfach
aufgebaut sind und von den meisten Programmen wie SPSS, Excel, R etc. ohne Probleme
verarbeitet werden können. Ein weiterer Vorteil der CSV– Dateien besteht darin, dass sie
aufgrund ihres einfachen Aufbaus programmunabhängig sind.
Abbildung 49 - Berechnungen mit dem Rasch-Modell
RM() ist jener wichtige Befehl, mit dem Analysen und Parameterschätzungen mittels
dichotomen logistischen Rasch-Modells durchgeführt werden. mat1 ist der Name unserer
Datenmatrix. Hat der Leser einen anderen Namen für seine Datenmatrix gewählt, dann muss
selbstverständlich dieser Name in den Befehl RM() eingefügt werden.
58
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Wichtig: Vergessen Sie bitte nicht, dass „R“ zwischen Groß– und Kleinschreibung strikt
unterscheidet. Das bedeutet, dass RM, rm, Rm und rM vier unterschiedliche Bedeutungen
haben. Wird RM mit rm verwechselt, kann das fatale Auswirkungen haben. Während
nämlich RM() eine Rasch-Modell –Analyse durchführt, ist rm() der Standardbefehl, um ein
Objekt aus dem Speicher zu löschen.
Das Ergebnis von RM(mat1) sieht man in Abbildung 50. Am Anfang der Ausgabe wird der
von eRm verarbeitete Befehl („Call“) ausgegeben. In diesem Beispiel lautet der „Call“:
RM(X=mat1). Danach wird die bedingte Log-Likelihood ausgegeben. In unserem Fall
beträgt die Log-Likelihood ungefähr -4731. Im Anschluss werden 14 eta-Parameter
ausgegeben. Für jeden dieser Parameter erhält man eine Schätzung (Estimate) und den
dazugehörigen Standardfehler (Std.Err).
Abbildung 50 - die Ausgabe eines einfachen RM
Wichtig: Überprüfen Sie immer, ob es sich um Itemschwierigkeits-Parameter oder um
Itemleichtigkeits-Parameter handelt.
59
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Zur weiteren Information: Wie lange die Berechnungen dauern, hängt sowohl von der
Größe Ihrer Datenmatrix (vor allem die Anzahl der Items entscheidet über die
Rechendauer) als auch von der Struktur Ihrer Datenmatrix und von den verwendeten
Befehlsoptionen ab. Je mehr Untergruppen verwendet werden, desto länger dauern die
Berechnungen. Auch der Standardfehler spielt eine Rolle – wird er berechnet, dann dauern
die Analysen erheblich länger.
Nachdem die erste Berechnung erfolgreich war und Schätzwerte für die Itemparameter
zurückgegeben wurden, wird eine weitere Rasch-Modell–Analyse durchgeführt. Im
Gegensatz zur ersten Analyse werden die Ergebnisse diesmal in der Variablen a gespeichert.
Dazu wird folgende Befehlssequenz eingegeben: a=RM(mat1) (Abbildung 51) oder
a<-RM(mat1). Es wird hier aber nochmals empfohlen, den Pfeil als Zuweisungs-Operator
zu verwenden. Genauer gesagt wird in Abbildung 51 ein Rm-Objekt von der Funktion RM()
erstellt und dieses Rm-Objekt wird dann in Variable a gespeichert. Objekte werden etwas
später noch genauer erklärt. Es soll hier nur gesagt werden, dass alles in „R“ ein Objekt ist.
Objekte sind unter anderem sehr gut für die Handhabung von zusammengehörigen Daten
geeignet, die aber von unterschiedlichem Typ (z.B. Matrizen, Vektoren, Text, Funktionen,
etc) sind.
Wichtig: Der Einfachheit halber wird hier gesagt, dass durch die RM()-Funktion ein RmObjekt erstellt wird. Das ist richtig, aber gleichzeitig ist dieses Objekt auch vom Typ dRm
und eRm. Dies soll der Vollständigkeit halber erwähnt werden. Der interessierte Leser wird
noch auf Kapitel 11 verwiesen.
Abbildung 51 - eine weitere RM - Berechnung
Nachdem ein Rm-Objekt in der Variablen a gespeichert wurde, werden keine Ergebnisse
mehr am Bildschirm ausgegeben. Der Vorteil dieser Vorgangsweise liegt darin, dass die in
Variable a gespeicherten Ergebnisse weiterverarbeitet werden können. Außerdem werden
60
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
verschiedene Ergebnisse (Objekte) als Eingabe für andere Funktionen benötigt. So braucht
z.B. LRtest() (diese Funktion berechnet einen bedingten Likelihood-Quotiententest nach
Andersen) ein Rm-Objekt als Input.
Um zu überprüfen, ob die Ergebnisse der Berechnung tatsächlich im Objekt a gespeichert
wurden, geben wir a in die Benutzeroberfläche ein (Abbildung 52).
Abbildung 52 - Ausgabe der Variablen a
61
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
8.3
Die Befehle print(), summary() und die Struktur von RmObjekten
Die Ausgabe in Abbildung 53 erhält man auch mit dem print() – Befehl. Man gibt dazu die
folgende Befehlssequenz ein: print(a)
Abbildung 53 - Ausgabe mit Hilfe des Befehls print()
Bis jetzt wurden die Daten nach dem einfachen Rasch-Modell mit dem Befehl RM()
analysiert und gleichzeitig die Itemparameter und Standardfehler geschätzt. Anschließend
sind die Ergebnisse als ein Rm-Objekt in der Variablen a gespeichert worden. Für eine
zusammenfassende Darstellung der Ergebnisse verwendet man den Befehl sum
summary()
und gibt folgende Befehlssequenz ein: sum
summary(a)
62
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 54 - der Befehl summary()
Nach der Eingabe von summary(a) (Abbildung 54) wird das Ergebnis auf dem
Bildschirm ausgegeben (Abbildung 55). Wie man sehen kann, werden bei weitem mehr
Informationen über unsere Ergebnisse ausgegeben als dies mit dem print()-Befehl der Fall
war. Vor allem werden hier die für die RM-Analyse wichtigen beta-Parameter ausgegeben.
Die Ausgabe beinhaltet dabei folgende Werte:
-
Call (der verarbeitete Befehl wird ausgegeben).
-
die Log-Likelihood – dieser Wert wird für verschiedene Berechnungen intern von
eRm gebraucht. Likelihood bedeutet übersetzt Mutmaßlichkeit oder Plausibilität und
gibt an, wie wahrscheinlich das Auftreten einer Datenmenge unter einem bestimmten
Modell ist. Für weitere Erklärungen zur Likelihood siehe Fischer (1974) oder Rost
(2004).
-
die Anzahl der Iterationen – sie gibt an, wie viele Durchläufe der Schätzalgorithmus
benötigte, um die Bedingung für eine Beendigung zu erfüllen.
-
zwei Tabellen: Die erste Tabelle „Basic Parameters (eta) …“ bezieht sich wieder auf
die eta-Parameter. Die eta-Parameter sind bei der RM-Analyse nicht so bedeutend wie
die beta-Parameter, die in der zweiten Tabelle ausgegeben und in diesem Handbuch
verwendet werden. Für die eta-Parameter und die beta-Parameter werden folgende
Werte ausgegeben:
o in der ersten Spalte die Namen der Itemparameter
o in der zweiten Spalte die Parameterschätzungen
o in der dritten Spalte die Standardfehler
o in der vierten Spalte die unteren Grenzen der Konfidenzintervalle
o und in der fünften Spalte die oberen Grenzen der Konfidenzintervalle
Die Konfidenzintervalle beruhen dabei auf einer 95%-Wahrscheinlichkeit. Aus Platzgründen
wurde darauf verzichtet alle eta-Parameter anzuzeigen (Abbildung 55).
63
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Results of RM estimation:
Call: RM(X = p1000i15.mat, sum0 = TRUE)
Conditional log-likelihood: -4731.239
Number of iterations: 24
Number of parameters: 14
Basic Parameters (eta) with 0.95 CI:
Estimate Std. Error lower CI upper CI
eta 1 -1.707
0.088 -1.880 -1.535
.
.
.
eta 14 1.087
0.078 0.933 1.240
Item Parameters (beta) with 0.95 CI:
Estimate Std. Error lower CI upper CI
beta col1 1.954
0.088 1.781 2.126
beta col2 -1.707
0.088 -1.880 -1.535
beta col3 2.614
0.101 2.415 2.813
beta col4 2.503
0.099 2.310 2.697
beta col5 -0.356
0.076 -0.504 -0.208
beta col6 -0.184
0.075 -0.331 -0.037
beta col7 1.800
0.086 1.632 1.968
beta col8 -1.684
0.088 -1.855 -1.512
beta col9 -1.462
0.084 -1.627 -1.296
beta col10 -1.310
0.083 -1.472 -1.148
beta col11 -0.752
0.078 -0.904 -0.600
beta col12 -1.660
0.087 -1.831 -1.489
beta col13 -0.409
0.076 -0.558 -0.261
beta col14 -0.433
0.076 -0.582 -0.285
beta col15 1.087
0.078 0.933 1.240
Abbildung 55 – die Ausgabe von summary(a)
Mit dem Befehl summary(a) werden die Ergebnisse der Berechnungen zuerst
zusammengefasst, dann formatiert und schließlich übersichtlich ausgegeben. Sollen wirklich
alle in einem Objekt gespeicherten Informationen ausgegeben werden, dann verwendet man
den Befehl str() und gibt folgendes ein: str(a) (Abbildung 56).
Abbildung 56 - der Befehl str()
64
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Mit diesem Befehl werden die komplette Objektstruktur und alle Daten ausgegeben, die in der
Variablen a gespeichert sind. Sind in einer Unterstruktur zu viele Daten für eine Ausgabe
gespeichert, dann wird der Benutzer mit 3 Punkten … darüber informiert (Abbildung 57).
Die Bildschirmausgabe des Objekts in Variable a wirkt im ersten Moment verwirrend, es
kann aber hilfreich sein, sich die Strukturen und Daten in einem Objekt anzuschauen
(Abbildung 57).
Abbildung 57 - die Objektstruktur, die in Variable a gespeichert ist
Ein Teil der in Abbildung 57 dargestellten Daten wird für die Ergebnisausgabe am
Bildschirm verwendet, ein Teil dieser Daten wird aber auch für weitergehende Berechnungen
intern verwendet. So benötigt z.B. der Befehl Waldtest() ein RM-Objekt. Ähnliches gilt
auch für andere Funktionen. So brauchen die Funktionen zur Berechnung der Fit-Statistiken
als Eingabe ein PPAR-Objekt, wie es von der Funktion person.parameter() erstellt
wird. Objekte werden in Kapitel 10 eingehender behandelt.
65
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Da das Rm-Objekt in Variable a wichtige Daten enthält, kommt man zu der Frage, ob und wie
man auf diese internen Daten zugreifen kann. Der Zugriff auf interne Strukturen geschieht
mittels des „$“-Operators. Man verwendet den Namen des Objektes (in diesem Fall wäre das
a), hängt das $-Zeichen an den Objektnamen an und hängt daran wiederum den Namen der
internen Struktur, die man entweder ausgeben oder ändern will. Verwendet man das RmObjekt aus Abbildung 58, dann kann man sich mit „a$betapar“ die Itemparameter
ausgeben lassen, Mit dem $-Zeichen kann man also auf die internen Strukturen eines
Objektes zugreifen. Will man diese Strukturen ändern, sollte man Vorsicht walten lassen und
eine Kopie des Originalobjektes erstellen. So eine Kopie kann man mit dem Befehl a <- b
generieren.
Abbildung 58 - Zugriff auf interne Objektstrukturen
Mit dem Befehl a$betapar kann man sich direkt die Itemparameter anzeigen lassen.
Selbstverständlich kann man die Itemparameter auch in einer Variablen speichern. (z.B.
c=a$betapar).
Wichtig: Bitte verwenden Sie nur die beta-Parameter als Itemparameter. Die betaParameter werden aus den eta-Parametern gebildet. Genauer gesagt, die Itemparameter
(also die beta-Parameter) werden als eine Summe von additiven, gewichteten
Basisparametern (eta-Parameter) gebildet.
66
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Das Objekt RM und die Bedeutung von verschiedenen Substrukturen
$X:
in dieser Struktur wird diejenige Datenmatrix gespeichert, die bei der Analyse
verwendet wurde
$X01: mit Hilfe dieser Struktur stehen dem Benutzer konstante Namen für die Personen
und Items zur Verfügung; dies ist wichtig, wenn Items oder Personen ausgeschlossen
werden müssen
$model: in dieser Struktur steht die Abkürzung des verwendeten Modells (z.B. RM steht
für das Rasch-Modell, LLTM steht für das linear logistische Testmodell, …)
$loglik: der Wert der Log-Likelihood
$npar: enthält die Anzahl der eta–Parameter
$iter: Anzahl der Iterationen (der Durchläufe), die gebraucht wurden, bis das
Kriterium zum Beenden erreicht wurde
$convergence: gibt an, ob der Algorithmus konvergiert hat
$etapar: enthält die eta-Parameter
$se.eta: enthält die Standardfehler der eta-Parameter
$hessian: enthält die Hesse-Matrix
$betapar: enthält die Itemparameter
$se.beta: enthält die Standardfehler der Itemparameter
$W: hier wird die Designmatrix gespeichert; diese Matrix definiert die Normierung der
Itemparameter; sie spielt aber beim einfachen Rasch-Modell eine untergeordnete Rolle.
$call: gibt den von eRm verarbeiteten Befehl aus
Abbildung 59 - Beschreibung der Strukturen eines Rm-Objektes
Zusammenfassung:
Durch die Verwendung des RM() – Befehls wird ein Objekt vom Typ Rm erzeugt.
Dieses Rm-Objekt, das gleichzeitig auch ein dRm-Objekt und ein eRm-Objekt ist,
verfügt über interne Strukturen, die mit dem Befehl str(Objektname) angesehen werden
können. Zugreifen kann man auf die internen Strukturen mit Hilfe des „$“-Zeichens.
67
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
8.4
Möglichkeiten des Befehls RM()
Abbildung 60 - Möglichkeiten des Befehls RM()
Die Variablen, die zur Übergabe von Werten an eine Funktion verwendet werden (in
unserem Fall X, se, W etc. nennt man Parameter. Wie man anhand von Abbildung 60
sehen kann, kann man nicht nur die Datenmatrix X , sondern auch verschiedene andere
Parameterwerte an die Funktion RM() übergeben.
Der Parameter W (Designmatrix) braucht bei der Analyse von Rasch-Modellen nicht
spezifiziert werden. (Man könnte hier eine eigene Designmatrix verwenden, wenn man
z.B. auf das 3. Item normieren will).
se ist eine logische Variable, die nur zwei Werte annehmen kann. T (TRUE) und F
(FALSE). Wird diese Variable auf FALSE gesetzt, dann werden die Standardfehler bei
Analysen nicht berechnet. Dies hat einen starken Einfluss auf die Rechenzeit. Nach
Delphi-Schätzung kann man ungefähr die Hälfte der Rechenzeit einsparen, wenn die
Standardfehler nicht berechnet werden. Wird se nicht explizit auf FALSE gesetzt, dann
werden die Standardfehler automatisch berechnet.
sum0 ist ebenfalls eine logische Variable, die nur die Werte TRUE und FALSE
annehmen kann. Enthält sum0 den Wert TRUE, dann wird bei der Berechnung die
Summennormierung verwendet. Hat sum0 den Wert FALSE, dann wird die
Itemnormierung verwendet. Wenn nichts anderes angegeben wird, dann ist sum0 auf
TRUE gesetzt und es wird die Summennormierung verwendet.
etastart - normalerweise verwendet die RM()-Funktion den Startwert 0 für die
Itemparameter, wenn es mit der Datenanalyse beginnt. Es kann nun aber sein, dass man
68
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
zusätzliche Informationen über die Itemparameter hat. Diese Informationen kann man an
die Funktion RM() übergeben. Dazu übergibt man die vermuteten Parameterschätzwerte
als Vektor an den Parameter etastart. Die Übergabe von Startwerten an RM() ist dann
sinnvoll, wenn die Berechnungen sehr lange dauern und man ungefähr weiß, wie die
Parameterwerte der einzelnen Items aussehen.
Eigene Notizen:
69
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
8.5
Weitere Berechungsmöglichkeiten
8.5.1 Schätzung von Personenparameter
Im Gegensatz zu den Itemparametern, die automatisch bei der Analyse des Rasch-Modells
geschätzt
werden,
müssen
die
Personenparameter
explizit
mittels
der
Funktion
per
person.parameter()
son.parameter geschätzt werden. Dazu muss der Inhalt der Variablen a (das
Ergebnis
unserer
vorherigen
Rasch-Modell-Analyse)
an
die
Funktion
person.parameter() übergeben werden. Die Befehlssequenz schaut dann so aus:
ppar1 = person.parameter(a)
Abbildung 61 – die Personenparameter werden geschätzt
Nachdem
die
Eingabe
mit
der
[RETURN]-Taste
beendet
wurde,
werden
die
Personenparameter geschätzt. Dabei gibt die Funktion person.parameter() ein pparObjekt zurück. Dieses Objekt „ppar“ wird in der Variablen ppar1 gespeichert. Das Ergebnis
bzw. das Objekt wird in einer Variablen gespeichert, weil andere Funktionen (z.B. FitStatistiken) dieses Ergebnis als Input brauchen.
Die bereits aus vorhergehenden Kapiteln bekannten Befehle print(), summary
summary() und
str() können wieder zur Ausgabe der Personenparameterschätzungen verwendet werden.
Wir geben print(ppar1) ein und auf dem Bildschirm werden die Personenparameter von
rv=1 bis rv=14 ausgegeben. rv steht für den Personenscore, also für die Anzahl der Items, die
eine Person v gelöst hat. Wie der Leser aus der Theorie weiß, können für Personenrohscores,
bei welchen kein Item gelöst wurde bzw. für Personenrohscores, bei denen alle Items gelöst
wurden, keine Personenparameter geschätzt werden. Diese Personenparameter können von
eRm „nur“ interpoliert werden. Aus diesem Grund ist für diese Personenparameter kein
Standardfehler angegeben (Abbildung 62).
70
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 62 – Ausgabe der Personenparameter von rv=0 bis rv=15
Mit dem Befehl summary (ppar1) kann man sich eine Zusammenfassung ausgeben
lassen, wobei in diesem Fall das Wort Zusammenfassung nicht gut gewählt ist, weil
summa
summary(ppar1) die Personenparameter von allen Personen inklusive der
Standardfehler ausgibt. Zusätzlich werden wieder die Collapsed Log-Likelihood, die Anzahl
der Iterationen und die Anzahl der verwendeten Parameter ausgegeben. Collapsed LogLikelihood bedeutet, dass Personen mit dem gleichen Rohscore zusammengefasst werden, um
die Berechnungen zu beschleunigen.
71
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 63 - Ausgabe der Personenparameter
Bei
den
Personenparametern
ist
der
Befehl
summary()
alles
andere
als
eine
Zusammenfassung und gibt für die Matrix mat1 die Personenparameter für alle 979 Personen
aus. Aus Platzgründen werden in Abbildung 63 nur die Daten der ersten 10 Personen
dargestellt.
Folgende Daten werden von summary bei ppar-Objekten ausgegeben:
-
die Collapsed Log-Likelihood
-
die Anzahl der Iterationen
-
die Anzahl der Parameter
-
eine Tabelle:
o in der ersten Spalte steht der Name der Person
o in der zweiten Spalte steht die Schätzung des Personenparameters
o in der dritten Spalte steht der Standardfehler
o in der vierten und fünften Spalte werden wieder die untere und die obere
Grenze des 95%-Konfidenzintervalls angegeben.
72
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Wie bereits erwähnt wurde, sind in Objekten (ppar1 ist ein ppar-Objekt) viele Informationen
in strukturierter Weise gespeichert. Um sich alle Informationen eines Objekts anzusehen,
verwenden wir den Befehl str(ppar1). In Abbildung 64 kann man die komplette interne
Struktur des Objektes ppar1 und alle darin gespeicherten Daten sehen. Auf die einzelnen
Substrukturen kann man wieder mittels „$“-Operator zugreifen. Um beispielsweise alle
Personenparameter auszugeben, gibt man ppar1$thetapar ein. Das Ergebnis kann man
sich in Abbildung 65 ansehen.
Tipp: Will man sich nur die Namen der Objektstrukturen ausgeben lassen, ist der Befehl
names() besser geeignet, da dann nur die Namen der Objektstrukturen ausgegeben
werden.
73
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 64 - die komplette interne Struktur des Objektes ppar
Abbildung 65 - die Personenparameter in kompakter Darstellung
74
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Da die Schätzung der Personenparameter wichtig ist, sollen hier die Strukturen des Objektes
ppar kurz beschrieben werden. Einige Strukturen sind schon von der Beschreibung des RmObjektes her bekannt.
Das Objekt ppar und die Bedeutung von verschiedenen Substrukturen
$X: in dieser Struktur wird die Datenmatrix gespeichert, die für die Berechnungen
verwendet worden ist
$X01: mit Hilfe dieser Struktur stehen dem Benutzer konstante Namen für die Personen
und Items zur Verfügung; dies ist wichtig, da es ansonsten sehr mühsam wäre, den
Überblick über die Daten zu behalten, wenn Items oder Personen ausgeschlossen werden
$W: hier wird die Designmatrix gespeichert
$model: in dieser Struktur steht die Abkürzung des verwendeten Modells (z.B. RM steht für
das Rasch-Modell, LLTM steht für das linear logistische Testmodell etc.)
$loglik: enthält den Wert der Log-Likelihood
$npar: Anzahl der Parameter
$iter: Anzahl der Iterationen (der Durchläufe), die gebraucht wurden, bis das Kriterium
zum Beenden erreicht wurde
$betapar: enthält die Itemparameter – diese Struktur ist identisch mit jener im Objekt RM
$thetapar: diese Struktur enthält die Personenparameter
$se.theta: enthält die Standardfehler der Personenparameter
$pred.list: in dieser Struktur sind die Personenparameter von rv=0 bis rv=15 gespeichert
(rv … Rohwert)
$hessian: enthält die geschätzte Hessematrix – diese Struktur wird vom Benutzer nicht
benötigt
$mpoints: enthält die Anzahl der Messpunkte
$pers.ex: enthält die ausgeschlossenen Personen
$gmemb: enthält die bei der Schätzung verwendeten Personen
75
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Die Struktur $pers.ex des Objektes ppar
Mit Hilfe von ppar1$pers.ex kann man kontrollieren, wieso Personen von einer
Personenparameterschätzung ausgeschlossen worden sind. Nach der Eingabe von
ppar1$pers.ex werden die Nummern von allen ausgeschlossenen Personen ausgegeben.
Abbildung 66 – von der Schätzung ausgeschlossene Personen
Mit der Befehlssequenz length(ppar1$pers.ex) erhält man die Anzahl der Personen, die
ausgeschlossen wurden. Der Befehl length() gibt die Länge einer Struktur (z.B. Vektor) an. In
diesem Fall wird die Zahl 21 ausgegeben. Wie wir bereits wissen, wurden 21 Personen
ausgeschlossen. An den Werten ppar1$X[33, ] und ppar1$X[34, ] soll nun kontrolliert
werden, wieso diese von der Berechnung ausgeschlossen worden sind. Dabei erhalten wir das
Ergebnis in Abbildung 67.
Abbildung 67 - Ergebnisse der Personen 33 und 34
Aus Abbildung 67 folgt, dass Person 33 alle Items richtig beantwortet hat. Damit kann der
Personenparameter nicht geschätzt werden und Person 33 muss von der Schätzung
ausgeschlossen werden. Person 34 dagegen hat kein Item gelöst und muss ebenfalls
ausgeschlossen werden. Um dennoch Parameter für die Extremscores (kein Item gelöst, alle
Items gelöst) zu erhalten, wendet eRm eine Interpolation an.
76
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Wichtig: eRm kann keine Personenparameter schätzen, wenn alle Items gelöst wurden (in
unserem Beispiel rv=15) oder wenn kein Item gelöst wurde (rv=0). Um dennoch
Personenparameter ausgeben zu können, werden diese Werte interpoliert.
Eigene Notizen:
77
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
8.5.2 Der bedingte Likelihood-Quotiententest (nach Andersen)
Nachdem in den vorhergehenden Kapiteln die Personen- und Itemparameter
für das
dichotome, logistische Rasch-Modell geschätzt wurden, sollen in den nächsten Kapiteln
Möglichkeiten demonstriert werden wie man Daten auf Rasch-Modell-Konformität
überprüfen kann.
Der Bedingte Likelihood-Quotiententest (LQT bzw. LRT) von Andersen (1973) überprüft, ob
sich die zu analysierenden Daten Rasch-Modell-konform verhalten. Dazu teilt man in einem
ersten Schritt die Stichprobe in zwei Personengruppen auf (Teilungskriterien sind dabei
Geschlecht, Alter, Leistung im Test, Schule etc.) und berechnet die Likelihoods der beiden
Untergruppen. In einem zweiten Schritt wird dann der CHi²-Wert berechnet. Für den LQT gilt
dabei: Ist der errechnetet Chi²-Wert kleiner als der kritische Chi²-Wert, dann wird die H0:
„Das Rasch-Modell gilt“ beibehalten. Ist der errechnete Chi²-Wert größer als der kritische
Chi²-Wert, dann muss die H0: „Das Rasch-Modell gilt“ verworfen werden. Mit jedem nicht
signifikanten LQT steigt dabei die Wahrscheinlichkeit, dass die H0 gültig ist (Popper spricht
dabei vom „Grad der Bewährung“).
Der Befehl zur Berechnung eines bedingten Likelihood-Quotiententests nach Andersen lautet:
LRtest(). Nach der Eingabe von LRtest erhält man die Abbildung 68.
LRtest (object, splitcr = "median", se = FALSE)
Abbildung 68 - die Möglichkeiten des LRtest
Wichtig: Wenn Mittelwert oder Median als Trennungskriterium verwendet werden, dann
müssen die Werte „mean“ und „median“ tatsächlich MIT den Anführungszeichen an
LRtest() übergeben werden. Ansonsten kommt es nämlich zu einer Fehlermeldung und
die Berechnung wird nicht gestartet. Der Grund dafür liegt am Umstand, dass R mean und
median ohne Anführungszeichen als Variablen interpretiert. Da diese Variablen aber nicht
existieren, kommt es zu einer Fehlermeldung.
Auch bei der Funktion Waldtest()
müssen mean und median in Anführungszeichen übergeben werden.
78
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Die Eingabemöglichkeiten für die Funktion LRtest()
Anhand von Abbildung 68 kann man erkennen, dass verschiedene Werte an den Befehl
LRtest() übergeben werden können.
object muss angegeben werden und muss ein Rm-Objekt sein. Rm-Objekte werden durch
die Verwendung der Funktion RM() erzeugt. Im Einführungsbeispiel wurde bereits ein RmObjekt erzeugt und in Variable a gespeichert. Dieses Objekt soll in diesem Beispiel
verwendet werden. Der LRtest akzeptiert derzeit nur Rm-Objekte als Input. Damit kann
LRtest() nur für das einfache Rasch-Modell verwendet werden.
splitcr ist das Teilungskriterium (Tk). Normalerweise werden externe Teilungskriterien wie
Alter, Geschlecht etc. oder interne Teilungskriterien wie die Anzahl gelöster Items
(Mittelwerte, Median) verwendet. Wird kein Teilungskriterium (Tk) angegeben, dann
verwendet LRtest() automatisch den Median. Wird ein externes Teilungskriterium verwendet,
müssen die Werte als ein Vektor an den Parameter splitcr übergeben werden. Vektoren
können u. a. mit der Funktion c() erstellt werden. Mit b=c(1,2,3,4,5) wird zum Beispiel
ein Vektor erstellt, der die Werte 1, 2, 3, 4 und 5 enthält. Natürlich muss der Vektor, der an
splitcr übergeben wird, für jede Person im Datensatz einen Wert haben.
se ist eine logische Variable, die nur zwei Werte annehmen kann. T (TRUE) und F
(FALSE). Wird diese Variable auf FALSE gesetzt, dann werden die Standardfehler beim
LQT nicht berechnet. Dies beeinflusst die Länge der Rechenzeit. Wird se nicht explizit auf
TRUE gesetzt, dann werden die Standardfehler nicht berechnet.
79
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Die Funktionen LRtest(), print(), summary() & str()
Um die Ergebnisse print(), summary() und str() zu erklären, wird ein einfaches Beispiel mit
dem LRtest gerechnet. Dazu wird wieder die Matrix mat1 verwendet.
Mit a=RM(mat1) wird ein Rm-Objekt erzeugt und in der Variablen a gespeichert,
während mittels lrt1=LRtest(a) ein LR-Objekt generiert und in Variable lrt1 gespeichert
wird. In diesem Beispiel wurden die Standardwerte der Funktion (keine Standardfehler,
Teilungskriterium ist der Median) verwendet. Mit print(lrt1) erhält man Abbildung 69.
Abbildung 69 - Ausgabe eines LRtest – Ergebnisses
Der in Abbildung 69 angezeigte „LR-Value“ ist der errechnete CHi²-Wert von LRtest, „df“
sind die Freiheitsgrade und „p-value“ ist die Fehlerwahrscheinlichkeit des Tests. Wir erhalten
also ein nicht signifikantes Ergebnis und behalten damit die H0: „Das Rasch-Modell gilt“ bei.
Der kritische Chi²-Wert kann „händisch“ berechnet werden, indem man folgende
Befehlssequenz eingibt: qchisq(p=1qchisq(p=1-alpha,df=14)
Dabei werden die Irrtumswahrscheinlichkeit „alpha“ und die Freiheitsgrade „df“ an
qchisq() übergeben. Mit summary(lrt1)
ausgegeben.
80
wird Abbildung 70 am Bildschirm
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 70 – LRT-Ergebnisse– Tk ist der Mittelwert
summary() liefert folgende Informationen:
„LR-Value“ ist der vom LRtest() errechnete Chi²-Wert. „Chi-square df“ sind die verwendeten
Freiheitsgrade. „p-value“ ist die Fehlerwahrscheinlichkeit (sie zeigt an, ob das Ergebnis
signifikant ist). Zusätzlich werden für jede der beiden Untergruppen, die durch das
Teilungskriterium definiert sind, die Log-Likelihood und die beta–Parameter ausgegeben. In
Abbildung 71 wird die interne Struktur des LR-Objektes dargestellt.
81
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 71 - interne Struktur von lrt1
82
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
In der folgenden weiterführenden Information wird die Struktur des LR-Objektes erklärt. Die
meisten Substrukturen sind durch das Rm-Objekt und das ppar-Objekt bereits bekannt.
Das Objekt LR
$X: in dieser Struktur wird die Datenmatrix gespeichert
$X.list: diese Variable enthält zwei Untergruppen ($low, $high). Die Personen sind in
dieser Variablen bereits nach dem Teilungskriterium in zwei Untergruppen aufgeteilt
$model: gibt das verwendete Rasch-Modell an (in diesem Fall RM)
$LR: gibt den errechneten CHI²-Werte an
$df: Freiheitsgrade
$pvalue : Fehlerwahrscheinlichkeit des Tests
$likgroup: gibt die Log-Likelihood der beiden Untergruppen an
$betalist: enthält die Itemparameter der beiden Untergruppen ($low, $high)
$etalist: enthält die eta–Parameter der beiden Untergruppen
$selist: enthält die Standardfehler für beide Untergruppen
Wichtig: Bitte vergessen Sie nicht, dass die Funktion LRtest() ein Rm-Objekt (also das
Ergebnis einer RM()-Berechnung) als Eingabe zwingend vorschreibt. In obigem Fall war
dieses Objekt in der Variablen a gespeichert.
Daraus ergibt sich die folgende
Befehlssequenz: lrt1=LRtest(a).
Mit dem bedingten LQT nach Andersen kann die Gültigkeit des RM-Modells überprüft
werden. Ein nicht signifikanter LQT bedeutet aber noch nicht, dass das Rasch-Modell
tatsächlich gilt. Es ist deshalb notwendig, den LQT mit weiteren Kriterien durchzuführen.
Diese Kriterien können z.B. Alter und Geschlecht sein. Wird ein externes Teilungskriterium
verwendet, dann müssen die Werte als ein Vektor an den Parameter splitcr übergeben
werden. Da es sich bei mat1 um eine simulierte Datenmatrix handelt, haben wir leider kein
echtes externes Kriterium wie Alter oder Geschlecht zur Verfügung. Aus diesem Grund wird
die Datenmatrix aufgeteilt, indem Person 1-500 die erste Gruppe und Person 501-1000 die
zweite Gruppe bilden. Wir nehmen an, dass in der ersten Gruppe alle Personen weiblich und
83
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
in der zweiten Gruppe alle Personen männlich sind. Den Teilungskriteriumsvektor erstellen
wir, indem wir folgende Sequenz eingeben: gs=c(rep(0,500), rep(1,500))
Damit wird ein Vektor in die Variable gs geschrieben, der zuerst 500 mal 0 und dann 500 mal
1 enthält. Ein LQT mit einem externen Teilungskriterium wird dann folgendermaßen
berechnet: lrt2=LRtest(a,splitcr=gs)
Das Ergebnis des obigen Befehls sieht man in Abbildung 72.
Abbildung 72 - LRtest() – externes Teilungskriterium
In Abbildung 72 liefert der LRTest mit dem „externen“ Kriterium einen sehr niedrigen Chi²Wert. Damit kann die H0: „Das Rasch-Modell gilt“ beibehalten werden.
Tipp: Zur Übung kann der Leser weitere LQTs mit verschiedenen Teilungskriterien
berechnen.
84
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
8.5.3 Der Grafische Modelltest (Rasch)
Nachdem mit zwei Teilungskriterien (Median, externes Kriterium) gezeigt wurde, dass das
Rasch-Modell nicht verworfen werden muss, soll nun mit Hilfe des Grafischen Modelltests
(GMT) untersucht werden, wie sich die einzelnen Items verhalten. Um einen Grafischen
Modelltest durchzuführen, kann man die R-Funktion plot() verwenden. Aber auch hier bietet
eRm eine eigene Funktion namens plotGOF() an. Als Input verlangt plotGOF() ein LRObjekt. An die Funktion plotGOF können die folgenden Werte übergeben werden:
plotGOF(x, beta.subset = "all", xlab = "Beta Group 1",
ylab = "Beta Group 2", tlab = "item", ylim = c(c(-3, 3), xlim = c(c(-3, 3),
type = "p", pos = "4", ...)
Optionen für die Funktion plotGOF()
x … ist ein LR-Objekt. Dieses Objekt muss an die Funktion übergeben werden
beta.subset … hier können mittels Vektor jene Items angegeben werden, die dargestellt
werden sollen (z.B beta.subset=c(1,2,3,4,5,6) oder beta.subset=c(3,8,9,10))
xlab … Beschriftung für die x-Achse (z.B. xlab=“x-Achse“)
ylab … Beschriftung für die y-Achse
tlab … mit dieser Option ist es möglich, die Art der Itemnamen zu ändern. Dabei können
die Werte „item“, „number“, „none“ verwendet werden. Mit „identify“ kann man sich sogar
die Namen der Punkte interaktiv (mittels Mausklick) anzeigen lassen.
xlim … setzt die Begrenzungen für die x-Achse
ylim … setzt die Begrenzungen für die y-Achse
(Die von plotGOF() verwendeten Standardwerte für die Grenzen sind mit dem Intervall von 3 bis +3 für beide Achsen etwas gering gewählt. Mit den Parametern xlim und ylim können
die Werte vom Benutzer überschrieben werden.)
pos … mit dem Parameter pos kann eine vordefinierte Position für die Itemlabels gewählt
werden (1…unten, 2…links, 3…oben, 4…rechts)
type … gibt den Typ der grafischen Darstellung an: sinnvoll sind nur die Optionen "p"
(Darstellung durch Punkte) und "n" (nur die Labels werden dargestellt)
85
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Tipp: plotGOF() bietet verschiedene grafische Möglichkeiten an. Es ist durchaus
lohnenswert, diese Optionen auszuprobieren.
Es werden nun verschiedene Darstellungsarten des Grafischen Modelltest vorgestellt. Bis
jetzt wurden die LR-Objekte lrt1und lrt2 erzeugt.
Diese beiden Objekte werden im
folgendem für die Darstellungen verwendet. Mit der folgenden Funktion erhalten Sie einen
Grafischen Modelltest wie er in Abbildung 73 zu sehen ist:
plotGOF(p1000i15.lrt1,xlim=c(plotGOF(p1000i15.lrt1,xlim=c(-4,4),ylim=c(4,4),ylim=c(-4,4), xlab="xxlab="xAchse",ylab="yAchse",ylab="y-Achse")
Abbildung 73 - Grafischer Modelltest - Median als Tk.
86
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Die Items in Abbildung 73 zeigen ein Rasch-Modell-konformes Verhalten und sind alle in der
Nähe der 45°-Geraden angesiedelt. Um einen Grafischen Modelltest für das externe
Teilungskriterium auf dem Bildschirm darzustellen, wird folgende Codesequenz eingegeben:
plotGOF(lrt2)
Nachdem keine Grenzwerte für die Achsen eingegeben wurden, setzt plotGOF() die
Grenzen für beide Achsen auf -3 bzw. +3 (Abbildung 74a).
Abbildung 74a - Grafischer Modelltest - externes Tk.
87
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Die Items der Datenmatrix 1 zeigen auch bei einem externen Teilungskriterium ein RaschModell-konformes Verhalten.
Bei den folgenden Beispielen werden nun verschiedene Darstellungen des Grafischen
Modelltests gezeigt. Es werden dabei immer der Median als Teilungskriterium und die
gleiche Datenmatrix verwendet. In Abbildung 74b wird auf die Ausgabe von Namen oder
Nummern für die Items verzichtet. Der dazugehörige Befehl lautet:
plotGOF(p1000i15.lrt_median, xlim=c(xlim=c(-3,3), ylim=c(ylim=c(-3,3), xlab="Das
ist die xAchse", ylab="Das ist die yy-Achse",
Achse", tlab="none")
Abbildung 74b - Grafischer Modelltest
88
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
In Abbildung 74c werden die Grenzen für die x-Achse und die y-Achse auf -3 und + 4
gesetzt. Als Benennung für die Items wird die Standardoption tlab=„item“ verwendet.
Damit werden die Standardnamen geplottet. Der dazugehörige Befehl lautet:
plotGOF(p1000i15.lrt_median, xlim=c(xlim=c(-3,4), ylim=c(ylim=c(-3,4), xlab="Das
ist die xx-Achse", ylab="Das ist die yy-Achse", tlab="item")
Abbildung 74c - Grafischer Modelltest
89
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
In Abbildung 74d werden Zahlen für die Benennung der Items verwendet. Die dazugehörige
Codesequenz lautet dann:
plotGOF(p1000i15.lrt_median, xlim=c(xlim=c(-3,3), ylim=c(ylim=c(-3,3), xlab="Das
ist die xx-Achse", ylab="Das ist die yy-Achse", tlab="number")
Abbildung 74d - Grafischer Modelltest
90
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
In Abbildung 74e werden nur die Items 1-5 dargestellt. Die Befehlssequenz lautet dann:
plotGOF(p1000i15.lrt_median, beta.subset=c(1,2,3,4,5), xlim=c(xlim=c(3,3), ylim=c(ylim=c(-3,3), xlab="Das ist die xx-Achse", ylab="Das ist die yyAchse", tlab="number")
Abbildung 74e - Grafischer Modelltest
Wichtige Info: Nachdem die Datenmatrix mittels der Funktion LRtest() einem
Likelihood-Quotiententest bezüglich des Standard-Teilungskriteriums Median als auch
bezüglich eines „externen“ Teilungskriteriums unterzogen worden ist, wurde im Anschluss
noch mittels der Funktion plotGOF() ein Grafischer Modelltest (GMT) durchgeführt, um
die einzelnen Items grafisch auf Rasch-Modell-Konformität zu prüfen.
91
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
8.5.4 Der Waldtest
Im Anschluss an die allgemeine Überprüfung der Daten mittels bedingten Likelihood-RatioTest (nach Andersen) und der einzelnen Items mittels Grafischem Modelltest sollen die Items
mittels Waldtest geprüft werden. Dazu werden der Mittelwert und ein willkürlich erstellter
Vektor als Teilungskriterien verwendet. Der Befehl zur Berechnung des Waldtests lautet:
Waldtest()
Waldtest (object, splitcr = "median")
Abbildung 75 - die Funktion Waldtest
Die Funktion Waldtest (Abbildung 75) verlangt zwingend die Eingabe eines Rm-Objekts.
Damit kann diese Funktion nur für Analysen nach dem einfachen Rasch-Modell verwendet
werden. Optional kann ein Teilungskriterium an den Waldtest übergeben werden.
Teilungskriterien können wieder Mittelwert, Median oder ein externer Vektor sein. Wird vom
Benutzer kein Teilungskriterium angegeben, dann wird der Median standardmäßig
verwendet. Für ein erstes Beispiel verwenden wir die folgende Syntax:
wald1=Waldtest(a, splitcr=“mean“).
Es wird wieder das Rm-Objekt von Kapitel 8.2 verwendet. Sollte das Rm-Objekt nicht mehr
vorhanden sein, kann es mit a=RM(mat1) erstellt werden. An die Waldtest()-Funktion
wird das Rm-Objekt a und das Teilungskriterium Mittelwert (mean) übergeben. Nach dem
Drücken der [RETURN]-Taste wird das Ergebnis als Wald-Objekt in Variable wald1
gespeichert. Mit print(wald1) erhält man folgende Darstellung (Abbildung 76) auf dem
Bildschirm. Aus Platzgründen wurde auf eine komplette Darstellung aller Items verzichtet.
92
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 76 – Waldtest – Teilungskriterium ist der Mittelwert
Mit
der
Funktion
Waldtest() werden die z-Werte und die dazugehörigen
Wahrscheinlichkeiten berechnet. Wie man anhand von Abbildung 76 erkennen kann,
unterschreitet kein P-Wert den vorher festgelegten Wert von 0.05. Damit ist in diesem
Beispiel kein Item signifikant und es dürfen alle Items weiterverwendet werden. Nach diesem
zufriedenstellenden Ergebnis wollen wir die interne Struktur von wald1 betrachten. Der
summary()–Befehl ist beim Wald-Objekt nicht definiert. Wir geben str(wald1) ein
und erhalten die folgende Ausgabe (Abbildung 77).
Abbildung 77 – die interne Struktur eines Wald-Objekts
93
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Die internen Strukturen des Wald-Objekts haben folgende Bedeutung.
Das Objekt Wald
$coef.table: in dieser Struktur sind jene Werte gespeichert, die beim print()–Befehl
ausgegeben werden. Das sind also die z-Werte (z-statistic) und die dazugehörigen
Irrtumswahrscheinlichkeiten (p-value)
$betapar1: in dieser Struktur sind die Itemparameter der ersten Untergruppe gespeichert
$se.beta1: in dieser Struktur sind die Standardfehler für die erste Untergruppe gespeichert
$betapar2: hier sind die Itemparameter der zweiten Untergruppe gespeichert
$se.beta2: hier sind die Standardfehler für die zweite Untergruppe gespeichert
Zum Abschluss soll noch ein Waldtest mit einem externen Teilungskriterium gerechnet
werden. Dazu wird ein einfacher Zufallsvektor mit der Funktion runif() erstellt. Die
Funktion runif(n, min, max) erstellt gleichverteilte Zufallszahlen zwischen min (dem
kleinsten Wert) und max (dem größten Wert). Die Anzahl der zufällig gezogenen Werte wird
über den Parameter n bestimmt. Die Werte werden noch mit der Funktion round() gerundet
und in Variable vk gespeichert. Es ergibt sich damit die folgende Sequenz:
vk=round(runif(1000,min=0,max=1))
vk=round(runif(1000,min=0,max=1))
Es wurde ein Vektor mit 1000 gleichverteilten Zufallszahlen erstellt. Dieser Vektor vk wird
an die Funktion Waldtest als Teilungskriterium übergeben. Das Ergebnis der Funktion
Waldtest() wird schließlich in der Variablen wald2 gespeichert. Wir geben also folgende
Befehlssequenz ein: wald2=Waldtest(a,splitcr=vk)
Das Ergebnis finden Sie in Abbildung 78. Da hier ein Vektor aus Pseudo-Zufallszahlen
verwendet wurde, erhalten Sie ein anderes Ergebnis.
94
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 78 - Waldtest-Ergebnis (ein externer Vektor als Tk)
Nachdem ein Zufallsvektor als Teilungskriterium verwendet wurde, findet man signifikante
Ergebnisse (Abbildung 78). Im Item Nr. 2 erhalten wir einen z-Wert über 2 und eine
Wahrscheinlichkeit, die bei einem Signifikanzniveau von 0.05 signifikant ist. Auch die Items
4 und 13 sind signifikant. Bitte vergessen Sie nicht, dass wir aus Demonstrationszwecken
zufallsverteilte Zahlen als Teilungskriterium verwendet haben!
Zusammenfassung: Mit der Funktion Waldtest() können Items auf Rasch-ModellKonformität geprüft werden. Dazu muss ein Rm-Objekt an die Funktion Waldtest()
übergeben werden. Optional kann auch ein Teilungskriterium angegeben werden. Für
Wald-Objekte ist die Funktion summary() nicht definiert.
95
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
8.5.5 Personfit und Itemfit
Neben dem bedingten Likelihood–Quotiententest (LQT) nach Andersen, dem Waldtest und
dem Grafischen Modelltest (GMT) stellt eRm noch weitere Funktionen zur Verfügung,
nämlich die Fit-Statistiken itemfit() und personfit()für die Überprüfung von Items und
Personen. Zusätzlich werden mit der Funktion pmat() die theoretischen Wahrscheinlichkeiten und mit der Funktion residuals() die standardisierten Residuen und die quadrierten
standardisierten Residuen ausgegeben. Alle 4 Funktionen benötigen als Eingabe ein pparObjekt. Dieses Objekt ist das Ergebnis einer Personenparameterschätzung mit der Funktion
person.parameter(). Um beispielsweise die Itemfit-Statistik der Datenmatrix mat1 zu
berechnen, müssen im ersten Schritt die Personenparameter geschätzt und in Variable a
gespeichert werden (siehe Kapitel 8.5.1). Im zweiten Schritt wird der Inhalt von Variable a an
die Itemfit-Funktion übergeben und das Resultat in Variable ifit gespeichert. Man muss also
folgende Codesequenz eingeben:
a=person.parameter(mat1);
a=person.parameter(mat1); ifit=itemfit(a); print(ifit)
Das Ergebnis steht in Abbildung 79.
Abbildung 79 - Fit-Statistik für die Itemparameter
96
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Die Funktion Itemfit() liefert die folgenden Werte:
-
in der ersten Spalte stehen die Itemnamen
-
in der zweiten Spalte stehen die CHI²-basierten Itemfit-Statistiken
-
in der dritten Spalte werden die Freiheitsgrade angegeben
-
in der vierten Spalte schließlich werden die Wahrscheinlichkeiten ausgegeben
Um die Fit-Statistik für die Personenparameter zu berechnen, verwendet man:
pfit=personfit(a) Man erhält dann die Ausgabe in Abbildung 80. (Aus Platzgründen
werden nur die ersten zehn Personen aufgelistet)
Abbildung 80 - Ausgabe der Personen-Fit-Statistiken
Die Funktion personfit liefert die folgenden Werte:
-
in der ersten Spalte stehen die Itemnamen
-
in der zweiten Spalte stehen die CHI²-basierten Personfit-Statistiken
-
in der dritten Spalte werden die Freiheitsgrade angegeben
-
in der vierten Spalte stehen die Wahrscheinlichkeiten ausgegeben
97
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Mit der Funktion pm=pmat(a) wird schließlich eine Liste zurückgegeben, die die
Personen-Item–Matrix mit den theoretisch zu erwartenden Wahrscheinlichkeiten enthält. Die
Matrix ist etwas unübersichtlich. Ein Teil dieser Matrix wird in Abbildung 81 dargestellt.
Abbildung 81 – Personen-Item-Matrix mit den erwarteten Wahrscheinlichkeiten
Die Funktion res=residuals(a) gibt schließlich die Residuen aus.
Eigene Notizen:
98
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
8.5.6 Die Informationsindices
Die Informationsindices AIC, BIC und CAIC überprüfen, welches Modell am besten auf die
Daten passt.
− Das AIC ist das Akaike Information Criterion und ist der älteste Informationsindex.
− Das BIC ist das Bayes Information Critierion (manchmal auch als Best Information
Criterion bezeichnet).
− Der dritte Informationsindex, der mittels eRm berechnet werden kann, ist das CAIC
(consistent Akaike Information Criterion).
Mittels Informationsindices ist es möglich, verschiedene Modelle miteinander zu vergleichen.
Dabei gilt: je kleiner der Informationsindex ist, desto besser passt das Modell.
Für die Berechnung der Informationsindices wird die Funktion IC() verwendet. An die
Funktion IC() muss ein ppar-Objekt, wie es von der Funktion person.parameter (also bei der
Berechnung der Personenparameter) erstellt wird, übergeben werden.
Nach
der
Eingabe
von
myIC=IC(ppar1) erstellt die Funktion IC() die
Informationsindices und speichert sie in der Variablen myIC. Mit print(myIC) werden die
Informationsindices und die unconditional joint log-likelihood (die unbedingte LogLikelihood) ausgegeben (siehe Abbildung 82).
Abbildung 82 - Ausgabe eines Ergebnisses der Funktion IC()
.
99
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
8.5.7 Weitere grafische Möglichkeiten
Zusätzlich zur Schätzung der Personenparameter bietet eRm für ppar-Objekte die Möglichkeit
einer grafischen Darstellung. Dabei werden auf der y-Achse die Personenparameter und auf
der x-Achse die dazugehörigen Rohscores aufgetragen. Nach der Eingabe von
plot(ppar1) erhält man die grafische Darstellung in Abbildung 83.
Abbildung 83 - Grafische Darstellung der Personenparameter
Auch für die Items werden mit den Funktionen plotICC() und plotjointICC() weitere
grafische Darstellungsmöglichkeiten angeboten. Mit der Funktion plotICC() können „Item
Characteristic Curves“ grafisch dargestellt werden. Die Eingabe sieht folgendermaßen aus:
a=RM(mat1)
plotICC(a)
100
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Das Ergebnis dieser Befehlssequenz sind die grafischen Darstellungen in Abbildung 84.
Dabei
werden
die
latenten
Dimensionen
auf
der
x-Achse
und
die
Lösungs-
wahrscheinlichkeiten auf der y-Achse aufgetragen.
Abbildung 84 - Grafische Darstellung der ICCs
Mit plotjointICC() können alle ICCs gleichzeitig auf dem Bildschirm dargestellt werden.
Nach der Eingabe der untenstehenden Sequenz erhalten wir die Darstellung in Abbildung 85.
a=RM(mat1)
plotjointICC(a)
.
101
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 85 - Grafische Darstellung aller ICCs
Auf
der
x-Achse
wurde
die
latente
Dimension
und
auf
der
y-Achse
die
Lösungswahrscheinlichkeit aufgetragen.
Zusammenfassung: Neben dem Grafischen Modelltest plotGOF() bietet eRm weitere
grafische Möglichkeiten. Mit der Funktion plot() (verlangt ein ppar-Objekt) können die
Personenparameter dargestellt werden. Mit der Funktion plotICC() (verlangt ein RmObjekt) können die Item-Charakteristik-Kurven grafisch ausgegeben werden. Schließlich
können mit der Funktion plotjoin
plotjointICC() (verlangt ein Rm-Objekt) können alle ICCs auf
einmal auf dem Bildschirm dargestellt werden.
102
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
9 Untergruppen und missing data
Wenn nicht genügend Zeit für eine Testung zur Verfügung steht oder die Testungen zu
umfangreich sind, um einer Person alle Aufgaben vorzugeben, können Untergruppen
verwendet werden. Untergruppen entstehen, indem Testpersonen unterschiedliche Itemsets
bearbeiten müssen. Die Testpersonen haben dann vom Design her fehlende Testwerte, es
handelt sich also um „missing data by design“. eRm hat nun die Fähigkeit mit Untergruppen
arbeiten zu können. Dies ist der große Pluspunkt gegenüber Softwarelösungen, die keine
„missing data by design“ verarbeiten können (z.B. Winmira).
Nachdem im vorigen Kapitel eine vollständige Datenmatrix für die Berechnungen verwendet
wurde, soll in diesem Kapitel an einem Beispiel die Arbeit mit Untergruppen demonstriert
werden. Die Eingabe der Daten für eine Datenmatrix mit mehreren Gruppen ist sehr einfach.
Dazu wird eine gewöhnliche Personen-Item–Matrix verwendet. In den Zeilen stehen die
Personen, in den Spalten stehen die Items. Zusätzlich wird noch das Symbol NA eingeführt.
Wenn eRm bzw. „R“ auf den Wert NA in einer Datenmatrix trifft, weiß das Programm
automatisch, dass es sich hier um einen fehlenden Wert handelt. Die Datenmatrix kann wie
gewohnt erstellt werden. Überall dort, wo eine Person bzw. eine Untergruppe ein Item nicht
bearbeitet hat, wird ein NA eingefügt. Die Matrix muss dabei weder nach Gruppen noch
sonstigen Kriterien geordnet sein. Ein Vorteil von eRm gegenüber anderen Programmen wie
LPCMWin, welches auch „missing values by design“ verarbeiten kann, ist dabei, dass die
anfallenden Zwischenschritte (Eingabe der Anzahl der Gruppen, Gruppengröße, sortieren der
Matrix nach Gruppen, Angabe der verwendeten Items pro Gruppe) von eRm selbstständig
erledigt werden. eRm sucht sich eigenständig die benötigten Informationen in der
Datenmatrix. Dieses automatisierte Vorgehen bedeutet nicht nur zusätzlichen Komfort,
sondern auch erhöhte Datensicherheit, da hier die Fehleranfälligkeit minimiert wird.
Bei diesem Beispiel wird nun eine Datenmatrix mit „missing values by design“ benötigt. Man
kann dazu die Beispieldatensätze verwenden, die von eRm selbst angeboten werden. Solche
Beispieldaten können mit dem Befehl data() geladen werden. Um die kleine Beispielmatrix
raschdat2 in den Speicher zu laden, geben Sie data(raschdat2) ein. Mit der
Befehlssequenz edit(raschdat2) kann man die Datenmatrix
überprüfen und
gegebenenfalls Änderungen vornehmen. Da diese Matrix sehr klein ist, wird sie hier nicht
103
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
verwendet. Dieses Handbuch verwendet stattdessen die Matrix mat2. Diese Rasch-Modellkonforme Matrix hat die Dimensionen von 2000 Personen und 20 Items. Außerdem besitzt
sie fünf Untergruppen. Da die mat2 als CSV-Datei vorliegt, kann sie mittels R-Commander
importiert werden.
Tipp: Diese Matrix kann wieder vom Arbeitsbereich Psychologische Diagnostik (Fakultät für
Psychologie) von der Homepage www.univie.ac.at/psychologie/diagnostik kopiert werden.
Zur weiteren Information: Programmpakete unter „R“ müssen nicht nur Funktionen
enthalten. Teilweise werden mit den Programmpaketen auch Beispieldaten mitgeliefert.
Diese Daten können mit dem Befehl data(DATENNAME) geladen werden. Mit data()
werden alle angebotenen Datensätze aufgelistet.
104
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
9.1
Rasch-Modell-Analyse einer Datenmatrix mit Gruppen
Nach dem Import der Datenmatrix wird mit folgender Befehlssequenz wieder ein RaschModell gerechnet: b=RM(mat2)
Es wird wieder der Befehl RM() zur Datenanalyse verwendet. Nach der Eingabe von
summa
summary(b) erhalten wir ein Ergebnis wie es in der Abbildung 86 dargestellt wird. Es
werden wieder die Log-Likelihood, die Anzahl der Iterationen und die die Anzahl der
Parameter ausgegeben. In der darauf folgenden Tabelle findet man die eta-Parameter. Dann
werden die 20 Itemparameter (beta-Parameter) angezeigt. Aus Platzgründen wurde auf die
Darstellung aller eta-Parameter verzichtet. In der ersten Spalte findet man den Namen, in der
zweiten Spalte die Parameterschätzungen, in der dritten Spalte die Standardfehler und in der
vierten und fünften Spalte sind die unteren und die oberen Grenzen des 95%-igen
Konfidenzintervalls dargestellt.
Das in b gespeicherte Ergebnis der Analyse unterscheidet sich also nicht vom Beispiel ohne
Untergruppen. Der aufmerksame Benutzer wird bemerken, dass bei dieser Berechnung die
Rechendauer angestiegen ist. Dies ist darauf zurückzuführen, dass die nun durchgeführten
Berechnungen um einiges komplexer sind, da die Matrix mat2 fünf Untergruppen beinhaltet.
Wichtig: Die Anzahl der Personen wirkt sich kaum auf die Dauer der Berechnung aus.
Wohl aber hat die Anzahl der Gruppen als auch die Anzahl der Items einen erheblichen
Einfluss auf die Dauer der Berechnungen. Dabei hat sich durch simulierte Berechnungen
gezeigt, dass der Schätzalgorithmus einem exponentiellen Laufzeitverhalten folgt. Dies
bedeutet, dass ab einer gewissen Anzahl von Items (insbesondere wenn viele
Untergruppen existieren) die Berechnungsdauer extrem groß wird. Um Zeit zu gewinnen,
gibt es zwei Möglichkeiten. Erstens kann man auf die Berechnung der Standardfehler
verzichten. Zweitens können Startwerte bei den Itemparameterschätzungen verwendet
werden. Beide Möglichkeiten wurden bereits diskutiert.
105
summary() –Ausgabe bei RM()
-
Log-Likelikhood
-
1. Tab.: enthält die eta-Parameter
-
2. Tab.: enthält die auf Nullsumme
normierte beta-Parameter – diese sind für
einfache Rasch-Modell-Analysen für
besonderer Bedeutung
-
Beide Tabellen zeigen folgende Werte
– Namen
– Parameterschätzung
die Anzahl der Iterationen
die Anzahl der Parameter
–
–
Standardfehler
95%iges Konfidenzintervall
Abbildung 86 – Zusammenfassung einer RM-Analyse
Mit str(b) kann sich der Benutzer wieder die interne Objektstruktur ansehen. Wie man
erkennen kann, gibt es zwischen Rasch-Modell-Analysen mit oder ohne Untergruppen nur
minimale Unterschiede.
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
9.2
Der bedingte LQT (Andersen) mit Untergruppen
Im Anschluss an die RM-Analyse wird jetzt ein bedingter Likelihood-Quotiententest
(Andersen)
gerechnet.
Wir
geben
dazu
folgendes
ein:
lrt3=LRtest(b,splitcr=“median“)
Wichtig: Bitte vergessen Sie nicht, dass LRtest() ein Rm-Objekt (also das Ergebnis einer
RM()-Analyse) als Eingabe benötigt. In unserem Fall ist dieses Objekt in der Variablen b
gespeichert worden. Daraus ergibt sich die Befehlssequenz: lrt3=LRtest(b)
Wir überprüfen das Ergebnis von LRtest() wiederum und sehen in Abbildung 87, dass es
auch hier kaum Unterschiede zwischen der LQT-Berechnung mit und ohne Untergruppen
gibt. Als Teilungskriterium wurde dabei der Median verwendet.
summary() liefert folgende Informationen:
LR-Value ist der vom LRtest() errechnete Chi²-Wert. Chi-square df sind die verwendeten
Freiheitsgrade. p-value ist die Irrtumswahrscheinlichkeit. Zusätzlich werden für die beiden
Untergruppen die Log-Likelihood und die beta-Parameter (die Itemparameter) ausgegeben.
Anschließend werden für die Parameter die Tabellen ausgegeben (Abbildung 87).
Abbildung 87 – LRT-Berechnung - Tk ist Median
107
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Der Vollständigkeit halber soll auch noch ein Grafischer Modelltest durchgeführt werden.
Wie man anhand von Abbildung 88 erkennen kann, zeigen die Items ein Rasch-Modellkonformes Verhalten. Zur Erstellung eines Grafischen Modelltests siehe Kapitel 8.5.3.
Abbildung 88 - der Grafische Modelltest – Median ist das Tk.
108
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
9.3
Personenparameter-Schätzung bei Untergruppen
Im nächsten Schritt werden die Personenparameter geschätzt. Dabei ist klar, dass es
erhebliche Unterschiede zwischen den Schätzungen mit Gruppen und ohne Gruppen geben
muss. Nachdem Matrix mat2 aus insgesamt fünf Gruppen besteht, müssen für jede Gruppe
die Personenparameter geschätzt werden. Der Grund liegt darin, dass die Untergruppen
unterschiedliche Itemsets bearbeitet haben. Zur Berechnung der Personenparameter
verwenden wir folgende Befehlssequenz:
ppar2=person.parameter(b)
ppar2=person.parameter(b)
Bei der anschließenden Ausgabe mit dem Befehl print(ppar2) zeigt eRm bei jeder Gruppe
zuerst, welche Items bearbeitet worden sind. Diese Information steht im NA-Pattern. Items,
die nicht bearbeitet worden sind, haben dabei den Wert NA. In der ersten Gruppe (siehe
Abbildung 89) wurden die Items 10, 17 und 18 nicht bearbeitet.
NA pattern: x x x x x x x x x NA x x x x x x NA NA x x
Abbildung 89 – NA-Pattern der Untergruppe 1
Anschließend wird für jede Gruppe eine Tabelle ausgegeben (Abbildung 90). In der ersten
Spalte steht der Rohscore rv, in der zweiten Spalte steht die Schätzung für den
Personenparameter einer Person mit Rohscore rv und in der dritten Spalte steht der
Standardfehler. NA gibt dabei an, dass kein Standardfehler berechnet werden konnte. Wie
schon erwähnt ist es nicht möglich den Rohscore von Personen zu schätzen, die kein Item
oder alle Items beantwortet haben. Ist so ein Extremfall eingetreten, dann interpoliert eRm
den entsprechenden Personenparameter. Mit Hilfe der Interpolation kann aber kein
Standardfehler berechnet werden. Wie man an den Schätzungen von Gruppe1 auch sehen
kann, interpoliert eRm auch jene Rohscores, die Personen unmöglich erreichen können. Da
eine Person in Gruppe 1 maximal einen Rohscore von 17 = 20 (alle Items) – 3 (Anzahl der
Items, die in Gruppe 1 nicht vorgegeben worden sind) erreichen kann, können nur die
Rohscores von rv=1 bis rv=16 geschätzt werden.
109
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Die Befehlssequenz print(ppar2) ergibt folgende Ergebnisdarstellung
Person NA Group: 1
NA pattern: x x x x x x x x x NA x x x x x x NA NA x x
Raw Score Estimate Std.Error
0 -3.58731505
NA
1 -3.14459640
NA
2 -2.70187776
NA
3 -2.25915912 0.7006513
4 -1.82086998
NA
5 -1.40915792 0.6180007
6 -1.03851558 0.6011960
7 -0.68295202 0.5924811
8 -0.33410289 0.5896803
9 0.01455856 0.5921548
10 0.36945636 0.6003415
11 0.73828755 0.6156077
12 1.13157105 0.6404534
13 1.59934533
NA
14 2.12970631
NA
15 2.69136064 0.8501845
16 3.25823054
NA
17 3.82510043
NA
18 4.39197033
NA
19 4.95884022
NA
20 5.52571012
NA
.
.
.
Person NA Group: 5
NA pattern: NA x x NA x x x x x x x x x x x NA x x NA x
Raw Score Estimate Std.Error
0 -3.2744338
NA
1 -2.8638039
NA
2 -2.4531739
NA
3 -2.0425440
NA
4 -1.6319141 0.6525822
5 -1.2263772 0.6237852
6 -0.8441656
NA
7 -0.4796718
NA
8 -0.1200553 0.6024325
9 0.2461292 0.6088556
10 0.6241040 0.6219463
11 1.0235110 0.6436731
12 1.4730686
NA
13 1.9546101 0.7348182
14 2.4414823
NA
15 2.9283546
NA
16 3.4152268
NA
17 3.9020990
NA
18 4.3889712
NA
19 4.8758434
NA
20 5.3627156
NA
Abbildung 90 – Ausgabe der Personenparameterschätzung
110
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Mit der Funktion summary(ppar2) werden die Personenparameter von allen Personen
ausgegeben, bei denen eine Schätzung möglich war. Personen, die alle Items falsch oder
richtig beantwortet haben, müssen von der Schätzung ausgeschlossen werden. Die Personen
werden dabei nach Untergruppen aufgeteilt in Tabellen ausgegeben. Dabei werden für jede
Tabelle der Name der Person, die Personenparameter, der Standardfehler für die
Personenparameter und die beiden Grenzen des Konfidenzintervalls ausgegeben. Zusätzlich
werden am Anfang jeder Tabelle die Log-Likelihood der Gruppe, die Anzahl der Parameter
und die Anzahl der Iterationen ausgegeben. Aus Platzgründen wurde darauf verzichtet, die
Personenparameterschätzung
hier
darzustellen.
Zum
Abschluss
des
Themas
„Personenparameter und missing data“ wollen wir noch die Strukturen untersuchen, die in der
Variablen ppar2 gespeichert sind.
Die Ausgabe der Objektstruktur von ppar2
List of 15
$X
: num [1:2000, 1:20] 0 0 0 1 0 0 0 0 0 1 ...
..- attr(*, "dimnames")=List of 2
.. ..$ : chr [1:2000] "P1" "P2" "P3" "P4" ...
.. ..$ : chr [1:20] "I1" "I2" "I3" "I4" ...
$ X01
: num [1:2000, 1:20] 0 0 0 1 0 0 0 0 0 1 ...
..- attr(*, "dimnames")=List of 2
.. ..$ : chr [1:2000] "P1" "P2" "P3" "P4" ...
.. ..$ : chr [1:20] "I1" "I2" "I3" "I4" ...
$W
: num [1:20, 1:19] -1 1 0 0 0 0 0 0 0 0 ...
..- attr(*, "dimnames")=List of 2
.. ..$ : chr [1:20] "beta I1" "beta I2" "beta I3" "beta I4" ...
.. ..$ : chr [1:19] "eta 1" "eta 2" "eta 3" "eta 4" ...
$ model : chr "RM"
$ loglik : num [1:5] -3328 -3060 -1479 -3930 -1761
$ npar : int [1:5] 470 480 211 533 256
$ iter : int [1:5] 8 11 8 8 8
$ betapar : Named num [1:20] -2.8964 1.5958 -1.4303 0.0174 2.2113 ...
..- attr(*, "names")= chr [1:20] "beta I1" "beta I2" "beta I3" "beta I4" ...
$ thetapar :List of 5
..$ NAgroup1: Named num [1:470] -0.6829 0.0146 0.0146 -0.6829 0.0146 ...
.. ..- attr(*, "names")= chr [1:470] "P2" "P8" "P20" "P25" ...
..$ NAgroup2: Named num [1:480] 0.233 -2.235 -0.958 -2.800 -0.173 ...
.. ..- attr(*, "names")= chr [1:480] "P1" "P4" "P6" "P9" ...
..$ NAgroup3: Named num [1:211] 0.146 0.491 -2.377 -2.377 -1.329 ...
.. ..- attr(*, "names")= chr [1:211] "P29" "P32" "P44" "P46" ...
..$ NAgroup4: Named num [1:533] -0.021 -2.205 1.045 0.314 -1.017 ...
.. ..- attr(*, "names")= chr [1:533] "P3" "P5" "P7" "P10" ...
..$ NAgroup5: Named num [1:256] -0.848 -0.848 1.024 1.955 2.565 ...
.. ..- attr(*, "names")= chr [1:256] "P13" "P15" "P22" "P24" ...
Abbildung 91 - die Struktur von ppar2
111
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
$ se.theta :List of 5
..$ NAgroup1: Named num [1:470] 0.592 0.592 0.592 0.592 0.592 ...
.. ..- attr(*, "names")= chr [1:470] "P2" "P8" "P20" "P25" ...
..$ NAgroup2: Named num [1:480] 0.643 0.708 0.626 0.808 0.632 ...
.. ..- attr(*, "names")= chr [1:480] "P1" "P4" "P6" "P9" ...
..$ NAgroup3: Named num [1:211] 0.586 0.591 0.821 0.821 0.657 ...
.. ..- attr(*, "names")= chr [1:211] "P29" "P32" "P44" "P46" ...
..$ NAgroup4: Named num [1:533] 0.575 0.697 0.631 0.584 0.588 ...
.. ..- attr(*, "names")= chr [1:533] "P3" "P5" "P7" "P10" ...
..$ NAgroup5: Named num [1:256] 0.609 0.609 0.644 0.735 0.838 ...
.. ..- attr(*, "names")= chr [1:256] "P13" "P15" "P22" "P24" ...
$ pred.list:List of 5
..$ 1:List of 2
.. ..$ x: int [1:21] 0 1 2 3 4 5 6 7 8 9 ...
.. ..$ y: num [1:21] -4.55 -3.65 -2.82 -2.26 -1.81 ...
.. ..- attr(*, "class")= chr "xyVector"
..$ 2:List of 2
.. ..$ x: int [1:21] 0 1 2 3 4 5 6 7 8 9 ...
.. ..$ y: num [1:21] -4.55 -3.64 -2.80 -2.23 -1.77 ...
.. ..- attr(*, "class")= chr "xyVector"
..$ 3:List of 2
.. ..$ x: int [1:21] 0 1 2 3 4 5 6 7 8 9 ...
.. ..$ y: num [1:21] -4.18 -3.24 -2.38 -1.80 -1.33 ...
.. ..- attr(*, "class")= chr "xyVector"
..$ 4:List of 2
.. ..$ x: int [1:21] 0 1 2 3 4 5 6 7 8 9 ...
.. ..$ y: num [1:21] -4.50 -3.59 -2.76 -2.20 -1.76 ...
.. ..- attr(*, "class")= chr "xyVector"
..$ 5:List of 2
.. ..$ x: int [1:21] 0 1 2 3 4 5 6 7 8 9 ...
.. ..$ y: num [1:21] -4.40 -3.49 -2.65 -2.09 -1.63 ...
.. ..- attr(*, "class")= chr "xyVector"
$ hessian :List of 5
..$ : num [1:470, 1:470] 2.848719 0.000091 0.000091 0.000000 0.000091 ...
..$ : num [1:480, 1:480] 2.416709 0.000000 0.000091 0.000091 0.000000 ...
..$ : num [1:211, 1:211] 2.92e+00 0.00e+00 0.00e+00 0.00e+00 -4.55e-05 ...
..$ : num [1:533, 1:533] 3.024797 0.000000 0.000000 -0.000091 0.000091 ...
..$ : num [1:256, 1:256] 2.70e+00 4.55e-05 0.00e+00 -4.65e-05 0.00e+00 ...
$ mpoints : num 1
$ pers.ex : int [1:50] 23 127 175 184 265 297 390 398 406 443 ...
$ gmemb : int [1:1950] 2 1 4 2 4 2 4 1 2 4 ...
- attr(*, "class")= chr "ppar"
Abbildung 91 – Fortsetzung: die Struktur von ppar2
Die Strukturen von ppar2 (mit Untergruppen) und ppar1 (ohne Untergruppen) ähneln
einander. Allerdings sind in ppar2 die Personenfähigkeitsparameter ($thetapar) in 5
Untergruppen aufgeteilt. Gleiches gilt auch für die Standardfehler ($se.thetapar), die HesseMatrix ($hessian), die Rohscores und ihre dazugehörigen Personenparameter ($pred.list).
Abschließend soll mittels Waldtest geprüft werden, ob die die einzelnen Items Rasch-Modellkonform sind. Wie man anhand von Abbildung 92 sehen kann, sind keine Items signifikant.
112
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Auch bei der Verwendung des Waldtests bemerkt man keine Unterschiede zwischen Daten
mit und ohne Untergruppen.
Abbildung 92 - Waldtest bei Daten mit Untergruppen
Zusammenfassung:
Bei der Analyse der Datenmatrix werden automatisch alle Informationen über die
Untergruppen aus der Datenmatrix gewonnen. Neben der Funktion RM gibt es auch
beim LRtest(), beim Waldtest() und beim grafischen Modelltest plotGOF() keine
Unterschiede zwischen Daten mit und ohne “missing values by design“. Nur bei der
Funktion person.parameter() gibt es Unterschiede bei der Ausgabe, da die
Personengruppen unterschiedliche Itemsets bearbeitet haben. Ein leider wenig
erfreulicher Unterschied zwischen Daten ohne Untergruppen und mit vielen
Untergruppen besteht in der Rechenzeit. Aufgrund der Komplexität und der
Datenmenge brauchen große Datenmatrizen mit vielen Items und vielen Untergruppen
sehr viel länger als Datenmatrizen mit wenig Items und wenigen Untergruppen.
113
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
10 Das Rm-Objekt
In diesem Kapitel wird ein einfacher Überblick über das Rm-Objekt gegeben. Für einen
Einblick in die Welt der Objekte, Methode und Funktionen wird auf Kapitel 11 – Objekte in
eRm verwiesen.
Das Rm-Objekt wird von der
RM()-Funktion erstellt und u. a. von diesen Funktionen
verwendet:
-
LRtest()
-
Waldtest()
-
person.parameter()
-
plotICC(), plotjointICC()
Dabei ist zu beachten, dass die Funktionen LRtest() und Waldtest() nur mit Rm-Objekten
arbeiten können. Dazu gehören neben dem RM, auch das RSM und das PCM. Für die
linearisierten Versionen (das LLTM, LRSM und LPCM) können kein Waldtest und kein
bedingter LRT gerechnet werden. Die Funktion person.parameter() akzeptiert
darüber hinaus mit Einschränkungen auch LLTM-, LRSM- und LPCM-Objekte. Damit kann
man auch bei diesen Modellen die Personenparameter schätzen.
Das LR-Objekt wird von der Funktion LRtest()
LRtest() generiert und von der Funktion
plotGOF() verwendet.
Das Wald-Objekt wird von der Funktion Waldtest() generiert. Dieses Objekt wird von
keiner anderen Funktion benötigt.
Das ppar-Objekt wird von der Funktion person.parameter() erzeugt und von den folgenden
Funktionen verwendet:
-
itemfit(), personfit()
-
pmat(), residuals()
-
plot(), IC()
Auf der folgenden Seite finden Sie eine vereinfachte Darstellung der Funktionen und
Beziehungen im Rm-Objekt.
114
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 93 – Beziehungen im Rm-Objekt
115
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
11 Objekte in eRm (von Reinhold Hatzinger)
In diesem Kapitel wird ein Überblick über Objekttypen, Funktionen und Methoden von eRm
gegeben. Im Anschluss werden Beispiele demonstriert.
Welche Objekttypen werden von welcher Funktion erzeugt
Funktion
RM()
PCM()
RSM()
LLTM()
LRSM()
LPCM()
Ausgabeobjekt ist vom Typ:
dRm, Rm, eRm
Rm, eRm
Rm, eRm
eRm
eRm
eRm
Abbildung 94-Objekttypen und ihre erzeugenden Funktionen
Welche Methode kann welche Objekttypen verarbeiten
Methode
Objekttyp der von Methode
verarbeitet werden kann:
dRm
dRm, Rm
plotjointICC()
LRtest()
plotICC()
Waldtest()
coef()
dRm, Rm, eRm
confint()
logLik()
model.matrix()
person.parameter()
print()
summary()
thresholds()*
vcov()
*(geht nur bei polytomen Modellen)
116
erzeugt von
RM()
RM(), PCM(), RSM()
RM(), PCM(), RSM(),
LLTM(), LRSM(), LPCM()
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Beispiele zur Demonstration:
Rasch Modell
resRM <- RM(dat) #
class(resRM)
# ergibt: [1] "dRm" "Rm" "eRm"
coef(resRM)
# alles funtioniert
LRtest(resRM)
plotjointICC(resRM)
Rating Scale Modell:
resRSM <- RSM(dat2) #
class(resRM)
# ergibt: [1] "Rm" "eRm"
coef(resRM)
# funktioniert
LRtest(resRM)
# funktioniert
plotjointICC(resRM).# funnktioniert nicht weil nicht „dRm“
Lineares Partial Credit Modell:
resLPCM <- LPCM(dat3, W=desmat)
class(resRM)
# ergibt: [1] "eRm"
coef(resRM)
# funktioniert
LRtest(resRM)
# funktioniert nicht weil nicht „Rm“
plotjointICC(resRM).# funktioniert nicht weil nicht „dRm“
117
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Grafische Darstellung: Schachtelung der Objekttypen und mögliche
Methoden
eRm: RM(), PCM(), RSM(). LLTM(), LRSM(), LPCM()
Rm: RM(), PCM(), RSM()
dRm: RM()
plotjointICC()
LRtest()
plotICC()
Waldtest()
coef()
confint()
logLik()
model.matrix()
person.parameter()
print()
summary()
thresholds() (nur bei polytomen Modellen)
vcov()
Abbildung 95 – Schachtelung der Objekttypen
118
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
12 Literaturverzeichnis
Andersen, E.B. (1973). A Goodness of Fit Test for the Rasch model. Psychometrika, 38, 123–
140.
Andrich, D. (1978). A rating formulation for ordered response categories. Psychometrika,
43(4), 561-573.
Fischer, G. H. (1973). The linear logistic test model as an instrument in educational research.
Acta Psychologica, 37, 359-374.
Fischer, G.H. (1974). Einführung in die Theorie psychologischer Tests [Introduction to
Mental Test Theory]. Huber, Bern.
Fischer, G.H. & Parzer, P. (1991). An Extension of the Rating Scale Model with an
Application to the Measurement of Change. Psychometrika, 56, 637–651.
Fischer, G.H. & Ponocny, I. (1994). An Extension of the Partial Credit Model with an
Application to the Measurement of Change. Psychometrika, 59, 177–192.
Fischer, G.H. & Ponocny-Seliger, E. (1998). Structural Rasch Modeling: Handbook of the
Usage of LPCM-WIN 1.0. ProGAMMA, Groningen.
Mair, P. & Hatzinger, R. (2007). eRm: extended Rasch modeling. R package version 0.9.5.
URL http://CRAN.R-project.org/.
Mair, P., & Hatzinger, R. (2007). Extended Rasch Modeling: The eRm Package for the
Application of IRT Models in R. Journal of Statistical Software, 20(9).
URL http://www.jstatsoft.org/v20/i09/.
Mair P., & Hatzinger, R. (2007). „CML based estimation of extended Rasch models with the
eRm package in R” . Psychology Science, Volume 49, 2007 (1), p. 26-43
Masters, G.N. (1982). A Rasch model for partial credit scoring. Psychometrika, 47, 149-174.
R Development Core Team (2006). R: A Language and Environment for Statistical
Computing. „R“ Foundation for Statistical Computing, Vienna, Austria. ISBN 3900051-07-0, URL: http://www.R-project.org.
Rasch, G. (1960). Probabilistic models for some intelligence and attainment tests.
Copenhagen: Danish Institute for Educational Research.
Scheiblechner, H. (1972). Das Lernen und Lösen komplexer Denkaufgaben. [The Learning
and Solving of Complex Reasoning Items.]. Zeitschrift f¨ur Experimentelle und
Angewandte Psychologie, 3, 456–506.
119
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
13 Empfehlenswerte Vertiefungsliteratur
Baker, F.B. & Kim, S. (2004). Item Response Theory: Parameter Estimation Techniques.
(2nd ed.).
New York: Dekker.
Bond, T. & Fox, C. (2001). Applying the Rasch model: Fundamental measurement in the
human sciences. Mahwah, NJ: Lawrence Erlbaum Associates, Inc.
Fischer, G.H. & Molenaar, I.W. (1995). Rasch Models. Springer-Verlag, New York.
ISBN 0-387-94499-0.
Kubinger, K.D. (1989). Aktueller Stand und kritische Würdigung der Probabilistischen
Testtheorie. In K.D. Kubinger (Hrsg.), Moderne Testtheorie - Ein Abriß samt neuesten
Beiträgen (S. 19-83), (2. Aufl.). München: Psychologie Verlags Union.
Kubinger, K.D. (2003). Skalierung. In K.D. Kubinger & R.S. Jäger (Hrsg.), Schlüsselbegriffe
der Psychologischen Diagnostik (S. 387-390). Weinheim: Beltz/PVU.
Kubinger, K.D. (2005). Psychological Test Calibration using the Rasch Model - Some
Critical Suggestions on Traditional Approaches. International Journal of Testing, 5,
377-394.
Kubinger, K.D. & Draxler, C. & (2007). Probleme bei der Testkonstruktion nach dem RaschModell. Diagnostica, 53, 131-143.
Rasch, D. & Kubinger, K.D. (2006). Statistik für das Psychologiestudium – Mit
Softwareunterstützung zur Planung und Auswertung von Untersuchungen sowie zu
sequentiellen Verfahren. Heidelberg: Spectrum.
Rizopoulos, D. (2006). ltm: An R Package for Latent Variable Modeling and Item Response
Theory Analyses. Journal of Statistical Software, 17(5), 1–25.
URL http://www.jstatsoft.org/v17/i05/.
Rost, J. (2004). Lehrbuch Testtheorie - Testkonstruktion. (2. Aufl.). Bern: Huber.
120
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
14 Nützliche Webseiten
Handbuch „extended Rasch modeling“
http://homepage.univie.ac.at/herbert.poinstingl/php/erm.php
http://www.univie.ac.at/psychologie/diagnostik
http://r-forge.r-project.org/
R-Forge – Unterstützung zu eRm
http://r-forge.r-project.org/
AB Psychologische Diagnostik - Universität Wien
http://www.univie.ac.at/psychologie/diagnostik
The R Project for Statistical Computing
http://www.r-project.org/
Comprehensive R Archive Network - CRAN
http://cran.r-project.org/
R-Handbücher auf CRAN
http://www.cran.r-project.org/doc/manuals/
R-Wikibooks
http://de.wikibooks.org/wiki/GNU_R
R-Wiki
http://wiki.r-project.org/rwiki/doku.php
R-Einführung auf CRAN
http://cran.r-project.org/doc/manuals/R-intro.html
Tinn-R
http://sourceforge.net/projects/tinn-r
121
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
15 FAQ – Frequently Asked Questions
1. Lösung für das Geschwindigkeitsproblem von
von importierten
Daten
Das Importieren von Daten verläuft an sich unproblematisch. Es kann aber sein, dass die
entsprechenden Daten als Listen in „R“ importiert werden. Listen können aber viele
Ressourcen benötigen und damit wird die Rechenzeit drastisch verlängert. Damit die Daten in
einer einfachen Matrix gespeichert werden, kann man folgende Befehlssequenz eingeben:
a=as.matrix(read.table("b.txt",sep=",")) Durch den Befehl as.matrix()
werden die Daten in eine Matrix konvertiert, die bei weitem weniger Mittel benötigt als eine
Liste.
2. Installation/Deinstallation von „R“„R“-Paketen
Programmpakete können folgendermaßen installiert werden. Dazu wählt man im Menüpunkt
„Pakete“ den Unterpunkt „Installiere Pakete“. Im nächsten Schritte wählt man das
Land (einen Server) aus, von dem man die Pakete installieren will. Abschließend muss man
im nächsten Fenster die Pakete auswählen, die installiert werden sollen. Mit dem Unterpunkt
„Aktualisiere Pakete“ schaut „R“ nach, ob neue Versionen der installierten Pakete auf
dem gewählten Server vorhanden sind. Mit dem Menüpunkt „Installiere Pakete aus
einem zip.File“ können auf der Festplatte bereits vorhandene Pakete ohne Internet
installiert werden. Mit dem Befehl remove.packages() können Pakete deinstalliert
werden. Ein manuelles Löschen der Package - Dateien sollte nicht vorgenommen werden.
3. Wie erstelle ich ein externes Teilungskriterium beim LRLR-Test
Das Erstellen eines externen Teilungskriteriums für den LRtest ist sehr einfach. Man übergibt
nämlich einen Vektor an die Funktion. Da man für jede Person die Gruppenzugehörigkeit
angeben muss, muss die Anzahl der Elemente im Vektor gleich der Zeilenanzahl der Matrix
sein.
122
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
4. Das Einlesen von RR-Code
Das Einlesen von R-Code in „R“ unter WINDOWS ist sehr einfach. Hier funktioniert das
Einlesen von R-Code über das Menü („Datei/Lese R-Code ein“). Unter LINUX muss man
allerdings mit dem Befehl source arbeiten und kann leider nicht auf Menüfunktionen
zurückgreifen. Den Befehl source wendet man folgendermaßen an. Beispiel:
source(„/home/
source(„/home/ info/R/rasch/1.r“)
Damit kann aus einem
bestimmten Verzeichnis eine R-Datei (in diesem Fall „1.r“)
eingelesen werden.
5. Verwendung eines externen Editors unter Windows – TinnTinn-R
Ein sehr guter, frei erhältlicher Editor für „R“ (unter WINDOWS) ist Tinn-R. Dieses
Programm arbeitet außerhalb von R, verfügt aber über Möglichkeiten, um „R“ zu steuern.
Zusätzlich besitzt Tinn-R Syntax-Highlighting für „R“-Code und eine kleine Hilfe-Datenbank
für „R“-Befehle.
6. Hilfe – die Rechendauer in eRm ist sehr lang
Die Anzahl der Personen wirkt sich kaum auf die Dauer der Berechnung aus. Wohl aber
haben die Anzahl der Gruppen als auch die Anzahl der Items einen erheblichen Einfluss auf
die Dauer der Berechnungen. Dabei hat sich durch simulierte Berechnungen gezeigt, dass der
Schätzalgorithmus einem exponentiellen Laufzeitverhalten folgt. Dies bedeutet, dass ab einer
gewissen Anzahl von Items (insbesondere wenn viele Untergruppen existieren) die
Berechnungsdauer extrem lang wird. Um Zeit zu gewinnen, gibt es dazu zwei Möglichkeiten.
Diese sind der Verzicht auf die Berechnung der Standardfehler und die Verwendung von
Startwerten.
7. Hilfe – eine Berechnung in „R“ dauert sehr lang
Es kann sein, dass Berechnungen sehr lange dauern, obwohl die importierte Datenmatrix
relativ klein ist. Dieses Phänomen tritt auf, wenn Datenmatrizen in einer komplexen Struktur
(z.B. eine Liste) in „R“ gespeichert sind und eigene Funktionen für Berechnungen verwendet
werden. Wurden in dieser Funktion Befehle verwendet, die nicht für Listenberechnungen
123
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
optimiert sind, steigt die Rechenzeit beträchtlich an. Um dieses Problem zu lösen, gibt es
zwei Möglichkeiten. Man schreibt die Funktion neu und verwendet die entsprechenden
Befehle von „R“ oder man konvertiert die komplexe Struktur in eine einfache Matrix und
führt dann die Berechnungen durch.
Eine Neuprogrammierung der entsprechenden Funktion ist sicher der beste Weg. Allerdings
kann dies eine sehr zeitintensive Angelegenheit sein, die nicht immer sofort durchgeführt
werden kann. Deshalb wollen wir das Objekt konvertieren und geben is.matrix(d) ein.
(Achtung – die Datenmatrix wurde vom Autor mit „d“ bezeichnet. Haben Sie einen anderen
Namen für Ihre Datenmatrix gewählt, dann müssen Sie selbstverständlich diesen Namen
eingeben.) Mit is.matrix() kann man überprüfen, ob ein Objekt eine einfache Matrix ist.
Wird hier ein FALSE zurückgeliefert, ist das Objekt keine Matrix.
Um eine Struktur in eine Matrix zu konvertieren, braucht man den Befehl as und den Namen
der Struktur. Mit der Befehlssequenz „d=as.matrix(d)
d=as.matrix(d)“ kann d in eine einfache Matrix
konvertiert werden. Die Konvertierung hat einen positiven Effekt auf die Geschwindigkeit der
Berechnungen, hat aber auch einen Nachteil. Der R-Commander kann mit einfachen Matrizen
nicht arbeiten. Wenn also eine Datenmatrix in eine echte Matrix umgewandelt wird, dann
kann die Matrix nicht mehr mit dem R-Commander bearbeitet werden.
Eigene Notizen:
124
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
16 Pakete für die Psychometrie
Die hier aufgeführte Auswahl an Programmpaketen soll die Arbeit erleichtern bzw.
zusätzliche Möglichkeiten für psychometrische Berechnungen bieten.
Wichtig: Prüfen Sie Ihre Programmpakete regelmäßig nach Aktualisierungen im Internet.
-
e1071 - Misc. Functions of the Department of Statistics (e1071), TU Wien
-
eRm - extended Rasch modeling
-
FactoMineR - Factor Analysis and Data Mining with R
-
gnomeGUI - GNOME Console for R
-
gsl - wrapper for the Gnu Scientific Library
-
HTMLapplets - Dynamic visualisation in HTML documents
-
iplots - iPlots - interactive graphics for R
-
irtoys - Simple interface to the estimation and plotting of IRT models
-
JavaGD - Java Graphics Device
-
JGR - JGR - Java Gui for R
-
lattice - Lattice Graphics
-
latticeExtra - Extra Graphical Utilities Based on Lattice
125
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
126
-
ltm - Latent Trait Models under IRT
-
misc3d - Miscellaneous 3D Plots
-
MiscPsycho - Miscellaneous Psychometrics
-
pscl - Political Science Computational Laboratory
-
psy - Various procedures used in psychometry
-
psych - Procedures for Personality and Psychological Research
-
psychometric - Applied Psychometric Theory
-
psyphy - Functions for analyzing psychophysical data in R
-
R.utils - Various programming utilities
-
R2HTML - HTML exportation for R objects
-
random - True random numbers using random.org
-
Rcmdr.HH - Rcmdr support for the introductory course at Temple University
-
Rcmdr - R Commander
-
RcmdrPlugin.TeachingDemos - Rcmdr Teaching Demos Plug-In
-
rgl - 3D visualization device system (OpenGL)
-
RGraphics - Data and Functions from the book R Graphics
-
rJava - Low-level R to Java interface
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
-
RMySQL - R interface to the MySQL database
-
scatterplot3d - 3D Scatter Plot
-
wle - Weighted Likelihood Estimation
-
xlsReadWrite - Natively read and write Excel files
-
xtable - Export tables to LaTeX or HTM
127
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
17 Matrix mat1
Die Matrix mat1 ist eine 1000 (Personen) x 15 (Items) – Datenmatrix, die für
Beispielberechnungen verwendet wurde. mat1 enthält keine Gruppen und wurde mittels einer
Simulation als Rasch-Modell-konforme Datenmatrix erzeugt. Diese Matrix kann vom AB
Psychologische Diagnostik von der Homepage www.univie.ac.at/psychologie/diagnostik
kopiert werden.
128
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
18 Matrix mat2
Die Matrix mat2 ist eine 2000 (Personen) x 20 (Items) – Datenmatrix, die für die Beispiele
mit Untergruppen verwendet wurde. mat2 wurde ebenfalls mittels Simulation als RaschModell-konforme Datenmatrix generiert. Sie kann ebenfalls vom AB Psychologische
Diagnostik
der
Fakultät
für
Psychologie
kopiert
werden
(www.univie.ac.at/psychologie/diagnostik).
129
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
19 Abbildungsverzeichnis
Abbildung 1 – Begrüßung durch R...........................................................................................17
Abbildung 2 - Auswahl des Menüpunkts "Installiere Pakete" .................................................17
Abbildung 3 - Wahl des Servers (in diesem Fall Austria)........................................................18
Abbildung 4 - Auswahl der gewünschten Pakete - in unserem Fall eRm ................................19
Abbildung 5 - das Paket „psy“ wurde geladen .........................................................................20
Abbildung 6 - Pakete laden über die GUI ................................................................................20
Abbildung 7 - Paket „psy“ wurde ausgewählt..........................................................................21
Abbildung 8 – die R-Benutzeroberfläche mit integriertem JGR..............................................22
Abbildung 9 - der Objektbrowser von JGR..............................................................................23
Abbildung 10 - Befehlseingabe unter JGR...............................................................................23
Abbildung 11 - der R-Commander benötigt weitere Pakete ....................................................24
Abbildung 12 - Installation vom lokalen PC oder von einem CRAN - Server ........................25
Abbildung 13 – das Statistikmenü der R-Commanders ...........................................................26
Abbildung 14 - das Grafikmenü des R-Commanders ..............................................................26
Abbildung 15 - weitere Hilfen des R-Commanders .................................................................27
Abbildung 16 - Datenimport mit dem R-Commander..............................................................27
Abbildung 17 – ein Plugin laden ..............................................................................................28
Abbildung 18 - Demonstrationen .............................................................................................28
Abbildung 19 - Power of the test..............................................................................................29
Abbildung 20 - ein Objekt vom Typ Matrix wird erstellt ........................................................30
Abbildung 21 - ein Array wird erstellt .....................................................................................31
Abbildung 22 - Berechnung der Faktoriellen ...........................................................................35
Abbildung 23 - Darstellung einer Sinuskurve ..........................................................................36
Abbildung 24 - Würfelsimulation ............................................................................................36
Abbildung 25 - Befehl für eine 3D-Ausgabe............................................................................37
Abbildung 26 - Darstellung einer 3D-Grafik ...........................................................................37
Abbildung 27 - Befehl zu einer weiteren 3D-Darstellung........................................................37
Abbildung 28 - 3D-Darstellung von Sinus und Kosinuswerten ...............................................38
Abbildung 29 - ein weiteres 3D-Beispiel .................................................................................38
Abbildung 30 - Berechnung von Pi nach der Monte Carlo - Methode.....................................39
Abbildung 31 - R-Commander laden .......................................................................................41
Abbildung 32 - der R-Commander ist einsatzbereit................................................................41
Abbildung 33 - Möglichkeiten des Datenimports ....................................................................42
Abbildung 34 - eine SPSS - Datei soll importiert werden........................................................43
Abbildung 35 - Import einer SPSS - Datendatei ......................................................................43
Abbildung 36 - Auswahl der Datendatei, die importiert werden soll.......................................45
Abbildung 37 –Import der SPSS-Datendatei mittels „read.spss“............................................46
Abbildung 38 - die Buttons "Datenmatrix bearbeiten" & "Datenmatrix betrachten" ..............46
Abbildung 39 – eine Datenmatrix ............................................................................................46
Abbildung 40 - R-Commander beenden...................................................................................47
Abbildung 41 - die Datenmatrix d ist keine Matrix..................................................................48
Abbildung 42 - die Datenmatrix d ist eine Liste ......................................................................48
Abbildung 43 – Sichere Workspace .........................................................................................51
Abbildung 44 – Datei zum Speichern auswählen.....................................................................52
Abbildung 45 – Lade Workspace .............................................................................................52
Abbildung 46 – Datei auswählen .............................................................................................53
Abbildung 47 - Formel des dichotomen, logistischen Rasch-Modells.....................................57
130
eexxtteennd
deed
dR
Raasscchh m
mood
deelliinng
g
Abbildung 48 – eRm wurde geladen.........................................................................................57
Abbildung 49 - Berechnungen mit dem Rasch-Modell............................................................58
Abbildung 50 - die Ausgabe eines einfachen RM....................................................................59
Abbildung 51 - eine weitere RM - Berechnung .......................................................................60
Abbildung 52 - Ausgabe der Variablen a .................................................................................61
Abbildung 53 - Ausgabe mit Hilfe des Befehls print() ............................................................62
Abbildung 54 - der Befehl summary() .....................................................................................63
Abbildung 55 – die Ausgabe von summary(a).........................................................................64
Abbildung 56 - der Befehl str() ................................................................................................64
Abbildung 57 - die Objektstruktur, die in Variable a gespeichert ist .......................................65
Abbildung 58 - Zugriff auf interne Objektstrukturen...............................................................66
Abbildung 59 - Beschreibung der Strukturen eines Rm-Objektes ...........................................67
Abbildung 60 - Möglichkeiten des Befehls RM() ....................................................................68
Abbildung 61 – die Personenparameter werden geschätzt.......................................................70
Abbildung 62 – Ausgabe der Personenparameter von rv=0 bis rv=15 ....................................71
Abbildung 63 - Ausgabe der Personenparameter .....................................................................72
Abbildung 64 - die komplette interne Struktur des Objektes ppar ...........................................74
Abbildung 65 - die Personenparameter in kompakter Darstellung ..........................................74
Abbildung 66 – von der Schätzung ausgeschlossene Personen ...............................................76
Abbildung 67 - Ergebnisse der Personen 33 und 34 ................................................................76
Abbildung 68 - die Möglichkeiten des LRtest .........................................................................78
Abbildung 69 - Ausgabe eines LRtest – Ergebnisses...............................................................80
Abbildung 70 – LRT-Ergebnisse– Tk ist der Mittelwert .........................................................81
Abbildung 71 - interne Struktur von lrt1 ..................................................................................82
Abbildung 72 - LRtest() – externes Teilungskriterium ............................................................84
Abbildung 73 - Grafischer Modelltest - Median als Tk. ..........................................................86
Abbildung 74a - Grafischer Modelltest - externes Tk..............................................................87
Abbildung 75 - die Funktion Waldtest .....................................................................................92
Abbildung 76 – Waldtest – Teilungskriterium ist der Mittelwert ............................................93
Abbildung 77 – die interne Struktur eines Wald-Objekts ........................................................93
Abbildung 78 - Waldtest-Ergebnis (ein externer Vektor als Tk) .............................................95
Abbildung 79 - Fit-Statistik für die Itemparameter ..................................................................96
Abbildung 80 - Ausgabe der Personen-Fit-Statistiken .............................................................97
Abbildung 81 – Personen-Item-Matrix mit den erwarteten Wahrscheinlichkeiten..................98
Abbildung 82 - Ausgabe eines Ergebnisses der Funktion IC() ................................................99
Abbildung 83 - Grafische Darstellung der Personenparameter..............................................100
Abbildung 84 - Grafische Darstellung der ICCs ....................................................................101
Abbildung 85 - Grafische Darstellung aller ICCs ..................................................................102
Abbildung 86 – Zusammenfassung einer RM-Analyse .........................................................106
Abbildung 87 – LRT-Berechnung - Tk ist Median ................................................................107
Abbildung 88 - der Grafische Modelltest – Median ist das Tk. ............................................108
Abbildung 89 – NA-Pattern der Untergruppe 1 .....................................................................109
Abbildung 90 – Ausgabe der Personenparameterschätzung ..................................................110
Abbildung 91 – Fortsetzung: die Struktur von ppar2 ............................................................112
Abbildung 92 - Waldtest bei Daten mit Untergruppen...........................................................113
Abbildung 93 – Beziehungen im Rm-Objekt .........................................................................115
Abbildung 94-Objekttypen und ihre erzeugenden Funktionen ..............................................116
Abbildung 95 – Schachtelung der Objekttypen......................................................................118
131