Anfängertutorial: Blicklenkung

Über OpenSesame

OpenSesame ist ein kostenloses Programm zur schnellen Entwicklung von Verhaltensexperimenten für Psychologie, kognitive Neurowissenschaften und experimentelle Ökonomie. Für Einsteiger:innen bietet OpenSesame eine umfassende grafische Point-and-Click-Oberfläche. Für fortgeschrittene Nutzer:innen unterstützt OpenSesame Python- und JavaScript-Skripting (dies wird in diesem Tutorial nicht behandelt).

Über dieses Tutorial

Wir erstellen ein klassisches Gaze-Cuing-Experiment. Dies ist ein unterhaltsames und interessantes Paradigma, bei dem Menschen unweigerlich dem Blick einer dargestellten Person folgen.

Wir verwenden ausschließlich die grafische Oberfläche. Wir programmieren nicht mit Python oder JavaScript. (Dies wird in den fortgeschrittenen Tutorials behandelt.) Dieses Tutorial dauert etwa eine Stunde.

Was du lernen wirst

Am Ende dieses Tutorials wirst du wissen, wie du:

• 💡 Eine Versuchsstruktur mit sequence- und loop-Items erstellst
• 💡 Ein vollfaktorielles Design mit unabhängigen Variablen in einer loop-Tabelle definierst
• 💡 Visuelle Reize mit sketchpad-Items erstellst
• 💡 Antworten mit keyboard_response-Items erfasst
• 💡 Teilnehmer:innen mit feedback-Items Rückmeldungen gibst
• 💡 Texte mit form_text_display-Items anzeigst
• 💡 Variablen zur Definition deiner Reize verwendest
• 💡 Bedingte (run-if) Ausdrücke benutzt, um den Ablauf deines Experiments zu steuern
• 💡 Stimulusdateien im Datei-Pool organisierst
• 💡 Daten protokollierst

Was du brauchst

OpenSesame 4.1 oder neuer mit allen installierten Updates. Wenn du eine Benachrichtigung über verfügbare Updates siehst, klicke auf „Updates installieren...“ und dann auf „Update-Skript ausführen“. Starte OpenSesame nach dem Update neu. Du kannst auch manuell aktualisieren, indem du folgenden Befehl in der OpenSesame-Konsole ausführst.

pip install opensesame-core opensesame-extension-sigmund --upgrade

Das Experiment

Wie bereits erwähnt, erstellen wir ein Gaze-Cuing-Experiment, das ursprünglich von [Friesen und Kingstone (1998)][references] entwickelt wurde. So funktioniert es:

1. Ein Gesicht erscheint in der Mitte des Bildschirms.
2. Das Gesicht blickt nach links oder rechts.
3. Ein Zielbuchstabe („F“ oder „H“) erscheint auf einer Seite.
4. Ein Ablenkungsbuchstabe („X“) erscheint auf der anderen Seite.
5. Die Teilnehmenden identifizieren den Zielbuchstaben so schnell wie möglich.

Das Experiment besteht aus einer Übungsphase und einer Experimentalphase. Nach jedem Block wird Feedback angezeigt. Nach falschen Antworten ertönt ein Ton.

Die interessante Entdeckung? Menschen sind schneller, wenn das Gesicht zum Ziel blickt, obwohl die Blickrichtung nicht vorhersagt, wo das Ziel erscheint. Das zeigt, dass wir Menschen automatisch Blicken folgen.

Figure 1. Das Gaze-Cuing-Paradigma [(Friesen und Kingstone, 1998)][references]. Dieses Beispiel zeigt einen inkongruenten Durchgang, da das Gesicht auf den Ablenker („X“) statt auf das Ziel („F“) blickt.

Schritt 1: Erstelle die Hauptsequenz

🎯 Ziel: In diesem Schritt erstellen wir die Grundstruktur unseres Experiments: eine Übungsphase, in der die Teilnehmenden die Aufgabe üben können; eine Experimentalphase, in der wir Daten für die Analyse sammeln; sowie informative Bildschirme vor und nach diesen Phasen. Hier wird nur die Struktur erstellt. Die Details werden später umgesetzt.

Beim Start von OpenSesame erscheint die Registerkarte „Get started!“ (Figure 2). Wähle „Standardvorlage“.

Figure 2. Das „Get started“-Panel beim Start von OpenSesame.

Öffne die Haupt-sequence mit dem Namen experiment. Sie enthält standardmäßig zwei Items: einen Notizblock (getting_started) und ein sketchpad (welcome).

Entfernen Sie die Standardelemente:

• Rechtsklick auf getting_started → Löschen
• Rechtsklick auf welcome → Löschen

Die experiment-sequence ist nun leer. Fügen Sie ein Formular für Anweisungen hinzu:

• Ziehen Sie ein form_text_display aus der Symbolleiste (Form) in experiment. Dies zeigt die Anweisungen am Anfang an (die tatsächlichen Anweisungen definieren wir im Schritt 12).

Fügen Sie eine loop mit einer sequence für die Übungsphase hinzu:

• Ziehen Sie eine loop in experiment (platzieren Sie diese nach dem Anweisungsformular).
• Ziehen Sie eine sequence in die loop und wählen Sie „In [Name des Loop-Elements] einfügen“.

Fügen Sie ein Formular am Ende der Übung hinzu

• Ziehen Sie in experiment ein weiteres form_text_display und wählen Sie „Nach [Name des Übungsloops] einfügen“. Dies zeigt eine „Ende der Übung“-Nachricht an (Schritt 12).

Fügen Sie eine loop für die Experimentierphase hinzu, und verwenden Sie eine verknüpfte Kopie derselben sequence wie bei der Übungs-loop:

• Ziehen Sie eine loop und fügen Sie sie nach dem Formular „Ende der Übung“ ein.
• Wiederverwenden Sie die sequence, die Sie für die Übungs-loop erstellt haben:
• Rechtsklick auf die bestehende sequence > Kopieren (verknüpft).
• Rechtsklick auf die neue Experimentier-loop > Einfügen > „In [Experimentier-Loop] einfügen“.

Fügen Sie ein Abschiedsformular hinzu:

• Ziehen Sie ein form_text_display und fügen Sie es nach der Experimentier-loop ein.

Benennen Sie die Elemente zur besseren Übersichtlichkeit um:

• new_form_text_display → instructions
• new_loop → practice_loop
• new_sequence → block_sequence (verknüpfte Kopien werden automatisch aktualisiert)
• new_form_text_display_1 → end_of_practice
• new_loop_1 → experimental_loop
• new_form_text_display_2 → end_of_experiment

Benennen Sie das Experiment um:

• Klicken Sie in der Übersicht auf New experiment. Benennen Sie es um in „Tutorial: Gaze cuing“. Dann speichern (Strg+S).

Figure 4. Overview at the end of Step 1.

Schritt 2: Die Blocksequenz erstellen

🎯 Ziel: In diesem Schritt fügen wir erneut Struktur zu unserem Experiment hinzu. Dieses Mal implementieren wir die Struktur für einen einzelnen Block von Durchgängen, der der block_sequence entspricht. Wir legen nur die Struktur fest. Details werden später implementiert.

Öffne block_sequence und füge die folgenden Items in dieser Reihenfolge hinzu:

• RESET_feedback (um die Feedback-Variablen am Anfang des Blocks zurückzusetzen)
• loop mit einer neuen sequence darin (um die eigentliche Schleife und Logik der Durchgänge zu steuern)
• feedback (um den Teilnehmern am Ende des Blocks Rückmeldung zu geben)

Umbenennen

• new_reset_feedback → reset_feedback
• new_loop → block_loop
• new_sequence → trial_sequence
• new_feedback → feedback

Figure 5. Übersicht am Ende von Schritt 2.

Schritt 3: Die Blockschleife mit unabhängigen Variablen füllen

🎯 Ziel: In diesem Schritt definieren wir die unabhängigen Variablen (Bedingungen) unseres Experiments. Unser Experiment ist ein Beispiel für ein vollständig randomisiertes Design, das bedeutet, dass unabhängige Variablen von Durchgang zu Durchgang variiert werden.

Öffne block_loop. Klicke auf Full-factorial design. Definiere:

• gaze_cue: left, right
• target_pos: -300, 300 (x-Koordinate in Pixel; 0 = Mitte; negativ = links)
• target_letter: F, H

Das ergibt 2×2×2 = 8 Kombinationen. Wir müssen auch einige Variablen hinzufügen, die sich aus den obigen Variablen ableiten. Dazu musst du manuell für jede Variable eine Spalte hinzufügen und die korrekten Werte in jede Zelle eintragen.

• dist_pos: Setze für jede Zeile 300, wenn target_pos -300 ist, und -300, wenn target_pos 300 ist
• correct_response: z für F, m für H
• congruency: kongruent, wenn der Blickhinweis in die Richtung des Ziels schaut, und inkongruent sonst

Stelle sicher, dass die loop-Tabelle aus 8 Zeilen besteht. Setze dann Wiederholen auf 3, damit wir am Ende 3 × 8 = 24 Durchgänge pro Block erhalten.

Figure 6. Die block_loop am Ende von Schritt 3.

Schritt 4: Bilder und Audiodateien zum Dateipool hinzufügen

🎯 Ziel: In diesem Schritt verwenden wir den Dateipool, um Stimulusdateien (Bilder und eine Audiodatei) mit dem Experiment zu bündeln.

Lade die folgenden Dateien herunter:

• gaze_neutral.png
• gaze_left.png
• gaze_right.png
• incorrect.ogg

Öffne den Dateipool (Strg+P) und ziehe die Dateien hinein. Oder benutze die + Taste, um sie hinzuzufügen. Der Dateipool wird automatisch mit deinem Experiment gebündelt.

Figure 7. Dateipool am Ende von Schritt 4.

Schritt 5: Die Versuchssequenz mit Items füllen

🎯 Ziel: In diesem Schritt definieren wir die Versuchssequenz. Für den Moment fügen wir nur die notwendigen Items hinzu, ohne sie zu definieren. Das holen wir später nach.

Ein Durchgang besteht aus:

1. Fixationspunkt — 750 ms — sketchpad
2. Neutraler Blick — 750 ms — sketchpad
3. Blickhinweis — 500 ms — sketchpad
4. Zielreiz — 0 ms — sketchpad (die 0 ms Dauer ermöglicht es dem Experiment, sofort zur Antwortabfrage weiterzugehen)
5. Antwortabfrage — keyboard_response
6. Fehler-Sound — sampler (wird nur bei falscher Antwort ausgeführt)
7. Log — logger

Öffne trial_sequence und die Items in der oben angegebenen Reihenfolge. Wenn du fertig bist, benenne sie um:

• new_sketchpad → fixation_dot
• new_sketchpad_1 → neutral_gaze
• new_sketchpad_2 → gaze_cue
• new_sketchpad_3 → target
• new_keyboard_response → keyboard_response
• new_sampler → incorrect_sound
• new_logger → logger

Setze in trial_sequence den Run-if für incorrect_sound auf: correct == 0. Es ist wichtig, ein doppeltes Gleichheitszeichen (==) zu verwenden, das prüft, ob zwei Werte identisch sind – in diesem Fall, ob correct gleich 0 ist. (Wenn du versehentlich ein einzelnes Gleichheitszeichen benutzt, correct = 1, erhältst du beim Ausführen des Experiments einen SyntaxError.)

Figure 8. trial_sequence am Ende von Schritt 5.

Schritt 6: Die Sketchpad-Items zeichnen

🎯 Ziel: In diesem Schritt definieren wir die vier sketchpad-Items der Versuchsequenz: Fixationspunkt, neutraler Blick (schaut geradeaus), Blickhinweis (schaut nach links oder rechts) und Zielanzeige (zwei Buchstaben auf jeder Seite des Blickhinweises, welcher weiterhin nach links oder rechts schaut).

Lege die Hintergrundfarbe des Experiments auf Weiß und die Vordergrundfarbe auf Schwarz fest:

• Klicke auf den Experimenttitel, um die allgemeinen Eigenschaften zu öffnen
• Ändere Background zu 'white' und Foreground zu 'black'

Definiere den Fixationspunkt:

• Öffne fixation_dot
• Wähle das Fixationspunkt-Element aus. Dies ist das Fixationspunkt-Symbol in der vertikalen Werkzeugleiste links der Zeichenfläche.
• Zeichne einen Fixationspunkt im Zentrum der Anzeige (0, 0)
• Setze die Dauer auf 745 ms. Dies wird auf die gewünschte Dauer von 750 ms aufgerundet.

Definiere die neutrale Blickanzeige:

• Öffne neutral_gaze
• Wähle das Bildelement aus
• Platziere ein Bild im Zentrum der Anzeige und wähle gaze_neutral.png im erscheinenden Datei-Pool-Dialog aus
• Setze die Dauer auf 745 ms

Definiere die Blickhinweisanzeige:

• Öffne gaze_cue
• Zeichne gaze_left.png im Zentrum der Anzeige

Natürlich soll nicht immer gaze_left.png angezeigt werden. Stattdessen soll gaze_left.png angezeigt werden, wenn die Variable gaze_cue "left" ist, und gaze_right.png, wenn die Variable gaze_cue "right" ist. Mit anderen Worten: Es soll gaze_{gaze_cue}.png angezeigt werden, wobei die geschweiften Klammern angeben, dass eine Variable eingefügt werden soll.

Dies können wir im Item-Skript angeben. Klicke Select view (das mittlere der drei Symbole oben rechts) → View script. Dadurch wird das sogenannte OpenSesame-Skript angezeigt, das das Item definiert. (Dies ist kein Python oder JavaScript!) Ändere den draw image-Befehl wie unten angegeben. Dabei kannst du auch die Dauer angeben (denk daran, dass 495 ms, wie oben erklärt, auf 500 ms aufgerundet werden):

set duration 495
set description "Displays stimuli"
draw image center=1 file="gaze_{gaze_cue}.png" scale=1 show_if=True x=0 y=0 z_index=0

Klicken Sie auf Übernehmen. Die Ansicht wechselt nun zurück zur Ansicht mit grafischen Steuerelementen. Das Bild erscheint jetzt als Fragezeichen. Keine Sorge! Das korrekte Bild wird während des Experiments angezeigt.

Definieren Sie die Zielanzeige:

• Öffnen Sie target
• Zeichnen Sie gaze_left.png in die Mitte der Anzeige.
• Wählen Sie das Textelement “textline” aus
• Zeichnen Sie "{target_letter}" irgendwo auf die linke Seite der Anzeige. Die genauen Koordinaten sind egal, da wir später eine Variable dafür verwenden werden. Wie zuvor zeigen die geschweiften Klammern an, dass die Variable target_letter eingefügt werden soll.
• Zeichnen Sie "X" irgendwo auf die rechte Seite der Anzeige

Bearbeiten Sie das Item-Skript (Ansicht auswählen → Skript anzeigen). Wie zuvor sollte der Blickhinweis (gaze cue) von der Variable gaze_cue abhängen. Zusätzlich sollte die X-Koordinate des Zielbuchstabens (“target letter”) von der Variable target_pos abhängen und die X-Koordinate des "X" von der Variable dist_pos.

Wichtig: Wir setzen die Dauer auf 0. Das bedeutet nicht, dass das Ziel 0 ms lang angezeigt wird, sondern dass das Experiment sofort zum nächsten Item weitergeht, das ein keyboard_response ist. Anders gesagt: Die Antwortaufnahme beginnt, sobald das Ziel erscheint!

set duration keypress
set description "Displays stimuli"
draw image center=1 file="gaze_{gaze_cue}.png" scale=1 show_if=True x=0 y=0 z_index=0
draw textline center=1 color=black font_bold=no font_family=mono font_italic=no font_size=32 html=yes show_if=True text="{target_letter}" x="{target_pos}" y=0 z_index=0
draw textline center=1 color=black font_bold=no font_family=mono font_italic=no font_size=32 html=yes show_if=True text="X" x="{dist_pos}" y=0 z_index=0

Schritt 7: Konfigurieren Sie das keyboard_response-Item

🎯 Ziel: In diesem Schritt konfigurieren wir, welche Tasten die Teilnehmenden zur Antwort nutzen können und wie lange sie Zeit haben.

Öffnen Sie keyboard_response:

• Lassen Sie “Korrekte Antwort” leer. Die Variable correct_response (aus Schritt 3) wird standardmäßig verwendet.
• Setzen Sie “Erlaubte Antworten” auf z;m
• Setzen Sie “Timeout” auf 2000 ms
• Lassen Sie “Ereignis-Typ” auf keypress

Figure 10. keyboard_response am Ende von Schritt 7.

Schritt 8: Konfigurieren Sie den sampler

🎯 Ziel: In diesem Schritt legen wir fest, welcher Ton nach einer falschen Antwort abgespielt werden soll.

Öffnen Sie incorrect_sound. Klicken Sie auf „Durchsuchen” und wählen Sie incorrect.ogg aus dem Datei-Pool aus.

Figure 11. incorrect_sound am Ende von Schritt 8.

Schritt 9: Konfigurieren Sie den logger

🎯 Ziel: In diesem Schritt überprüfen wir, wie die Daten protokolliert werden.

Öffnen Sie logger. Standardmäßig ist „Automatisch alle Variablen protokollieren” aktiviert. Das ist eine gute Vorgehensweise, deshalb müssen wir hier nichts ändern!

Schritt 10: Zeichnen Sie das Feedback-Element

🎯 Ziel: In diesem Schritt definieren wir das Feedback, das die Teilnehmer:innen am Ende jedes Blocks zu ihrer Leistung erhalten.

Öffnen Sie feedback. Lassen Sie die Dauer auf 'keypress'. Fügen Sie folgenden Feedback-Text hinzu:

Ende des Blocks

Ihre durchschnittliche Reaktionszeit war {avg_rt} ms
Ihre Genauigkeit betrug {acc} %

Drücken Sie eine beliebige Taste, um fortzufahren

Figure 12. feedback am Ende von Schritt 10.

Schritt 11: Legen Sie die Anzahl der Blöcke für die Übungs- und Experimentalphase fest

🎯 Ziel: In diesem Schritt geben wir die Anzahl der Durchgangsblöcke in der Übungs- und Experimentalphase an.

Öffnen Sie practice_loop und setzen Sie Wiederholen auf 2, sodass wir zwei Übungsblöcke haben. Fügen Sie außerdem eine practice-Variable zur Schleifen-Tabelle hinzu und setzen Sie diese auf 'yes'. Dies ist praktisch, da Sie bei der Datenanalyse leicht erkennen können, welche Durchgänge Teil der Übungsphase waren.

Öffnen Sie experimental_loop und setzen Sie Wiederholen auf 8. Fügen Sie ebenfalls eine practice-Variable hinzu, setzen Sie diese diesmal aber auf 'no'.

Schritt 12: Schreiben Sie die Anweisung, end_of_practice und end_of_experiment Formulare

🎯 Ziel: In diesem Schritt fügen wir informative Anweisungen an verschiedenen Stellen im Experiment hinzu.

Öffnen Sie die drei form_text_display-Elemente und geben Sie kurze, klare Instruktionen ein. Gute Anleitungen sind einfach, vollständig und spezifisch!

Schritt 13: Führen Sie das Experiment durch!

🎯 Ziel: In diesem Schritt führen wir einen ersten Testlauf des Experiments durch!

Der doppelte blaue Pfeil in der Symbolleiste ist die Quick run (Strg+Shift+W) Schaltfläche. Damit wird das Experiment in einem Fenster mit einer Dummy-Versuchsnummer und einem Logfile-Pfad gestartet. Dies ist hauptsächlich während der Entwicklung nützlich.

Der einzelne grüne Pfeil ist die Run fullscreen (Strg+R) Schaltfläche. Hier werden Sie zuerst nach einer Versuchsnummer und einem Logfile gefragt und ob Sie das Experiment im Vollbild- oder Fenstermodus starten wollen. Diese Funktion ist hauptsächlich für die Datenerhebung gedacht.

Drücken Sie eine der beiden Schaltflächen, um Ihr Experiment zu testen!

🏁 Wenn das Experiment läuft, sind Sie fertig! Aber bevor Sie aufhören, besprechen wir noch zwei weitere wichtige Punkte bezüglich Debugging und Backend-Auswahl:

Effektives Debugging und Verständnis von Fehlern

Fehler beim Erstellen von Experimenten sind normal. Lesen Sie Fehlermeldungen sorgfältig und versuchen Sie, sie zu verstehen. Das ist der einzig wahre Weg zum effektiven Debugging!

Figure 13 zeigt eine Beispiel-Fehlermeldung:

• Der Fehlertyp ist FStringError
• Die Beschreibung gibt an: „Failed to evaluate f-string expression in the following text: gaze_{gaze_ceu}.png”
• Der Fehler ist in der Prepare-Phase der gaze_cue-Elemente aufgetreten
• Das Traceback ist eine Python-Fehlermeldung. Sie ist eine technischere Version der obigen Beschreibung.

Figure 13. Eine Fehlermeldung in OpenSesame.

Sobald du verstanden hast, woher der Fehler kommt, kannst du versuchen, ihn zu beheben. In diesem Beispiel resultiert der Fehler aus einem Tippfehler bei der Definition des gaze_cue-Items in Schritt 6. gaze_{gaze_ceu}.png sollte gaze_{gaze_cue}.png sein. Leicht behoben!

Timing und Backend-Auswahl

Im Tab 'Allgemeine Eigenschaften' (der Tab, den du öffnest, indem du auf den Namen des Experiments klickst), kannst du ein Backend auswählen. Das Backend ist die Softwareschicht, die die Anzeige, Eingabegeräte, Ton usw. steuert. Die meisten Experimente funktionieren mit allen Backends, aber es gibt Gründe, eines gegenüber dem anderen zu bevorzugen, meist im Zusammenhang mit dem Timing. Derzeit gibt es vier Backends:

• psycho ist der Standard. Es basiert auf PsychoPy und bietet ein exzellentes Timing [(Peirce, 2007)][references].
• xpyriment — basiert auf Expyriment und bietet ebenfalls ein exzellentes Timing [(Krause & Lindemann, 2013)][references]
• legacy — ist eine Fallback-Option, die auf mehr Systemen funktioniert, aber weniger präzises Timing bietet
• osweb — führt Experimente im Browser aus [(Mathôt & March, 2022)][references]

Siehe auch:

• https://osdoc.cogsci.nl/4.1/de/manual/backends
• https://osdoc.cogsci.nl/4.1/de/manual/timing

Wichtigste Erkenntnisse

Du hast gelernt, wie man ein einfaches, aber vollständiges Experiment erstellt!

• ✅ Die Struktur eines Experiments wird üblicherweise durch die Kombination von sequence- und loop-Items erstellt
• ✅ Variablen werden üblicherweise in der loop-Tabelle definiert
• ✅ Zeitkritische visuelle Stimuli werden üblicherweise mit einem sketchpad präsentiert
• ✅ Rückmeldungen für Teilnehmende werden üblicherweise mit feedback-Items präsentiert
• ✅ Das form_text_display ist praktisch, um Text anzuzeigen
• ✅ Variablen und Ausdrücke können mit geschweiften Klammern eingefügt werden. Beispiel: {gaze_cue}
• ✅ Run-if-Ausdrücke werden in einer sequence definiert und bestimmen, welche Items tatsächlich ausgeführt werden: Beispiel: correct == 0
• ✅ Überprüfe immer das Timing und die Logdateien mit einem umfassenden Testrun, bevor du Daten sammelst

Nächste Schritte

Du hast nun ein grundlegendes Verständnis von OpenSesame. Das reicht aus, um viele einfache Experimente zu erstellen. Möglicherweise möchtest oder musst du jedoch noch mehr lernen! Hier sind sinnvolle nächste Schritte:

• Lerne, wie du zusammen mit SigmundAI Experimente erstellst
• Lerne, wie du Python-Code in deinen Experimenten verwendest
• Lerne, wie du JavaScript-Code in deinen Online-Experimenten einsetzt

Literatur