Tutorial para principiantes: direccionamiento de la mirada

Sobre OpenSesame

OpenSesame es un programa gratuito para el desarrollo rápido de experimentos conductuales en psicología, neurociencia cognitiva y economía experimental. Para principiantes, OpenSesame cuenta con una interfaz gráfica integral y de apuntar y hacer clic. Para usuarios avanzados, OpenSesame admite la programación en Python y JavaScript (no cubierto en este tutorial).

Sobre este tutorial

Crearemos un experimento clásico de dirección de mirada. Este es un paradigma divertido e interesante, donde las personas no pueden evitar seguir hacia dónde mira una cara.

Solamente usaremos la interfaz gráfica. No utilizaremos programación en Python ni JavaScript. (Esto se cubre en los tutoriales intermedios). Este tutorial toma aproximadamente una hora.

Lo que aprenderás

Al finalizar este tutorial, sabrás cómo:

• 💡 Construir la estructura de un experimento con elementos sequence y loop
• 💡 Definir un diseño factorial completo con variables independientes en una tabla loop
• 💡 Crear estímulos visuales con elementos sketchpad
• 💡 Recoger respuestas con elementos keyboard_response
• 💡 Proporcionar retroalimentación a los participantes con elementos feedback
• 💡 Mostrar texto usando elementos form_text_display
• 💡 Utilizar variables para definir tus estímulos
• 💡 Usar expresiones condicionales (run-if) para controlar el flujo de tu experimento
• 💡 Organizar los archivos de estímulos en el file pool
• 💡 Registrar datos

Lo que necesitarás

OpenSesame 4.1 o posterior con todas las actualizaciones instaladas. Si ves una notificación sobre actualizaciones disponibles, haz clic en "Install updates..." y luego en "Run update script." Reinicia OpenSesame después de actualizar. También puedes actualizar manualmente ejecutando el siguiente comando en la consola de OpenSesame.

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

El experimento

Como se mencionó, crearemos un experimento de dirección de mirada, desarrollado originalmente por Friesen y Kingstone (1998). Así funciona:

1. Una cara aparece en el centro de la pantalla
2. La cara mira hacia la izquierda o hacia la derecha
3. Una letra objetivo ('F' o 'H') aparece en un lado
4. Una letra distractora ('X') aparece en el otro lado
5. Los participantes identifican la letra objetivo lo más rápido posible

El experimento tiene una fase de práctica y una fase experimental. Mostrarás retroalimentación después de cada bloque. Un sonido suena tras respuestas incorrectas.

¿El hallazgo interesante? Las personas son más rápidas cuando la cara mira hacia el objetivo, aunque la dirección de la mirada no predice dónde aparecerá el objetivo. Esto muestra que los humanos siguen automáticamente hacia donde otros están mirando.

Figure 1. The gaze-cuing paradigm (Friesen and Kingstone, 1998). This example shows an incongruent trial, because the face looks at the distractor ('X') instead of the target ('F').

Paso 1: Crea la secuencia principal

🎯 Objetivo: En este paso, crearemos la estructura básica de nuestro experimento: una fase de práctica, durante la cual los participantes podrán practicar la tarea; una fase experimental, durante la cual recogeremos datos para el análisis; y pantallas informativas antes y después de estas fases. Solo estableceremos la estructura. Los detalles se implementarán después.

Cuando inicies OpenSesame, aparecerá la pestaña ‘¡Comencemos!’ (Figure 2). Elige “Default template”.

Figure 2. The ‘Get started’ panel on OpenSesame start-up.

Abre la sequence principal llamada experiment. Contiene dos elementos por defecto: un notepad (getting_started) y un sketchpad (welcome).

Elimina los elementos predeterminados:

• Haz clic derecho en getting_started → Eliminar
• Haz clic derecho en welcome → Eliminar

La SECUENCIA experiment ahora está vacía. Agrega un formulario para las instrucciones:

• Arrastra un form_text_display desde la barra de herramientas (Form) a experiment. Esto mostrará las instrucciones al inicio (definiremos las instrucciones reales en el Paso 12).

Agrega un loop con una SECUENCIA para la fase de práctica:

• Arrastra un loop a experiment (colócalo después del formulario de instrucciones).
• Arrastra una SECUENCIA dentro del loop y elige "Insertar en [nombre del elemento loop]".

Agrega un formulario al final de la práctica

• En experiment, arrastra otro form_text_display y elige "Insertar después de [nombre del elemento practice loop]". Esto mostrará un mensaje de "fin de práctica" (Paso 12).

Agrega un loop para la fase experimental, reutilizando una copia vinculada de la misma SECUENCIA que usaste para el loop de práctica:

• Arrastra un loop y colócalo después del formulario de fin de práctica.
• Reutiliza la SECUENCIA que creaste para el loop de práctica:
• Haz clic derecho en la SECUENCIA existente > Copiar (vinculado).
• Haz clic derecho en el nuevo loop experimental > Pegar > "Insertar en [loop experimental]".

Agrega un formulario de despedida:

• Arrastra un form_text_display e insértalo después del loop experimental.

Renombra los elementos para mayor claridad:

• new_form_text_display → instructions
• new_loop → practice_loop
• new_sequence → block_sequence (las copias vinculadas se actualizan automáticamente)
• new_form_text_display_1 → end_of_practice
• new_loop_1 → experimental_loop
• new_form_text_display_2 → end_of_experiment

Renombra el experimento:

• Haz clic en New experiment en la vista general. Renombra como “Tutorial: Gaze cuing”. Luego guarda (Ctrl+S).

Figure 4. Overview at the end of Step 1.

Paso 2: Crea la secuencia de bloque

🎯 Objetivo: En este paso, nuevamente añadiremos estructura a nuestro experimento. Esta vez implementaremos la estructura para un solo bloque de ensayos, que corresponde a block_sequence. Solo estableceremos la estructura. Los detalles se implementarán más adelante.

Abre block_sequence y añade los siguientes elementos en orden:

• RESET_feedback (para restablecer las variables de retroalimentación al inicio del bloque)
• loop con una nueva sequence insertada (para manejar la lógica real del bucle y el ensayo)
• feedback (para brindar retroalimentación al participante al final del bloque)

Renombra

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

Figure 5. Overview at the end of Step 2.

Paso 3: Llena el block loop con variables independientes

🎯 Objetivo: En este paso, definiremos las variables independientes (condiciones) de nuestro experimento. Nuestro experimento es un ejemplo de diseño completamente aleatorizado, lo que significa que las variables independientes varían de un ensayo a otro.

Abre block_loop. Haz clic en Full-factorial design. Define:

• gaze_cue: left, right
• target_pos: -300, 300 (coordenada x en píxeles; 0 = centro; negativo = izquierda)
• target_letter: F, H

Esto crea 2×2×2 = 8 combinaciones. También necesitamos definir varias variables que se derivan de las anteriores. Para esto, necesitas agregar manualmente una columna para cada variable e ingresar los valores correctos en cada celda.

• dist_pos: Para cada fila, pon 300 si target_pos es -300, y -300 si target_pos es 300
• correct_response: z para F, m para H
• congruency: congruente si la dirección de la mirada apunta hacia el objetivo, e incongruente de lo contrario

Asegúrate de que la tabla del loop tenga 8 filas. Luego pon Repetir en 3 para tener 3 × 8 = 24 ensayos por bloque.

Figure 6. The block_loop at the end of Step 3.

Paso 4: Agrega imágenes y archivos de sonido al file pool

🎯 Objetivo: En este paso, usaremos el file pool para agrupar archivos de estímulo (imágenes y un sonido) junto con el experimento.

Descarga los siguientes archivos:

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

Abre el file pool (Ctrl+P) y arrastra los archivos dentro. O bien, usa el botón + para agregarlos. El file pool se agrupa automáticamente con tu experimento.

Figure 7. File pool at the end of Step 4.

Paso 5: Llena la trial sequence con elementos

🎯 Objetivo: En este paso, definiremos la secuencia de ensayo. Por ahora, solo añadiremos los elementos necesarios sin definirlos. Lo haremos más adelante.

Un ensayo consiste en:

1. Punto de fijación — 750 ms — sketchpad
2. Mirada neutral — 750 ms — sketchpad
3. Señal de mirada — 500 ms — sketchpad
4. Objetivo — 0 ms — sketchpad (la duración de 0 ms permite que el experimento avance de inmediato a la recolección de respuestas)
5. Recolección de respuesta — keyboard_response
6. Sonido incorrecto — sampler (solo si es incorrecto)
7. Registro — logger

Abre trial_sequence y los ítems en el orden indicado arriba. Cuando termines, renómbralos:

• 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

En trial_sequence, configura run-if para incorrect_sound a: correct == 0. Es importante usar el doble signo igual (==), que verifica si dos valores son idénticos, en este caso si correct es igual a 0. (Si accidentalmente utilizas un solo signo igual, correct = 1, obtendrás un SyntaxError al ejecutar el experimento.)

Figure 8. trial_sequence al final del Paso 5.

Paso 6: Dibuja los ítems sketchpad

🎯 Objetivo: En este paso, definiremos los cuatro ítems sketchpad de la secuencia del ensayo: punto de fijación, mirada neutral (mirando al frente), señal de mirada (mirando a la izquierda o derecha) y pantalla de objetivo (dos letras a cada lado de la señal de mirada, que sigue mirando a la izquierda o derecha).

Configura el color de fondo del experimento a blanco y el color de primer plano a negro:

• Haz clic en el título del experimento para abrir las Propiedades generales
• Cambia Background a 'white' y Foreground a 'black'

Define el punto de fijación:

• Abre fixation_dot
• Selecciona el elemento fixdot. Este es el ícono del punto de fijación en la barra de herramientas vertical a la izquierda del lienzo.
• Dibuja un punto de fijación en el centro de la pantalla (0, 0)
• Configura la duración a 745 ms. Esto se redondeará a la duración deseada de 750 ms.

Define la pantalla de mirada neutral:

• Abre neutral_gaze
• Selecciona el elemento de imagen
• Dibuja una imagen en el centro de la pantalla y elige gaze_neutral.png en el diálogo del archivo pool que aparece.
• Establece la duración en 745 ms

Define la pantalla de señal de mirada:

• Abre gaze_cue
• Dibuja gaze_left.png en el centro de la pantalla

Por supuesto, no siempre queremos mostrar gaze_left.png. Más bien, queremos mostrar gaze_left.png cuando la variable gaze_cue es "left", y gaze_right.png cuando la variable gaze_cue es "right". Es decir, queremos mostrar gaze_{gaze_cue}.png, donde las llaves indican que se debe insertar una variable.

Podemos especificar esto en el script del ítem. Haz clic en Select view (el del medio de los tres íconos en la parte superior derecha) → View script. Esto muestra el llamado script de OpenSesame que define el ítem. (¡Esto no es Python ni JavaScript!). Cambia el comando draw image como se indica abajo. Ya que lo haces, también puedes definir la duración (recuerda que 495 ms se redondeará a 500 ms, como se explicó arriba).

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

Haz clic en Aplicar. La vista ahora regresa a la vista de controles gráficos. La imagen ahora aparece como un signo de interrogación. ¡No te preocupes! La imagen correcta se mostrará durante el experimento.

Define la presentación objetivo:

• Abre target
• Dibuja gaze_left.png en el centro de la pantalla.
• Selecciona el elemento textline
• Dibuja "{target_letter}" en algún lugar del lado izquierdo de la pantalla. Las coordenadas exactas no importan, porque más adelante usaremos una variable para ello. Como antes, las llaves indican que se debe insertar la variable target_letter.
• Dibuja "X" en algún lugar del lado derecho de la pantalla

Edita el script del item (Selecciona vista → Ver script). Como antes, la señal de mirada debe depender de la variable gaze_cue. Además, la coordenada X de la letra objetivo debe depender de la variable target_pos y la coordenada X de la "X" debe depender de la variable dist_pos.

Es importante destacar que establecemos Duración en 0. Esto no significa que el objetivo se muestre durante 0 ms. Más bien, esto significa que el experimento avanza inmediatamente al siguiente item, que es un keyboard_response. ¡En otras palabras, la recolección de respuestas comienza tan pronto como se muestra el objetivo!

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

Paso 7: Configura el item keyboard_response

🎯 Objetivo: En este paso, configuraremos las teclas que los participantes pueden usar para responder, y cuánto tiempo tienen para responder.

Abre keyboard_response:

• Deja en blanco Respuesta correcta. Por defecto se usará la variable correct_response (del Paso 3).
• Establece Respuestas permitidas en z;m
• Establece el Tiempo límite en 2000 ms
• Deja el Tipo de evento en keypress

Figure 10. keyboard_response al final del Paso 7.

Paso 8: Configura el sampler

🎯 Objetivo: En este paso, especificaremos qué sonido debe reproducirse después de una respuesta incorrecta.

Abre incorrect_sound. Haz clic en Buscar y selecciona incorrect.ogg de la biblioteca de archivos.

Figure 11. incorrect_sound al final del Paso 8.

Paso 9: Configura el logger

🎯 Objetivo: En este paso, revisaremos cómo se registran los datos.

Abre logger. Por defecto, “Registrar automáticamente todas las variables” está habilitado. Esto es una buena práctica, así que no es necesario cambiar nada aquí.

Paso 10: Dibujar el elemento de retroalimentación

🎯 Objetivo: En este paso, definiremos la retroalimentación que los participantes reciben sobre su desempeño al final de cada bloque.

Abre feedback. Deja la duración en 'keypress'. Agrega el siguiente texto de retroalimentación:

Fin del bloque

Tu tiempo de respuesta promedio fue de {avg_rt} ms
Tu precisión fue de {acc} %

Presiona cualquier tecla para continuar

Figure 12. feedback al final del Paso 10.

Paso 11: Establecer el número de bloques para la fase de práctica y experimental

🎯 Objetivo: En este paso, especificaremos el número de bloques de ensayos tanto en la fase de práctica como en la fase experimental.

Abre practice_loop y configura Repetir en 2, para que tengamos dos bloques de práctica. También agrega una variable de práctica a la tabla del bucle y asígnale el valor 'yes'. Esto es conveniente porque, durante el análisis de datos, nos permitirá identificar fácilmente cuáles ensayos fueron parte de la fase de práctica.

Abre experimental_loop y configura Repetir en 8. Nuevamente, agrega una variable de práctica, pero esta vez asígnale el valor 'no'.

Paso 12: Escribir las formas de instrucciones, end_of_practice y end_of_experiment

🎯 Objetivo: En este paso, añadiremos mensajes informativos e instrucciones a lo largo del experimento.

Abre los tres elementos form_text_display e ingresa instrucciones breves, claras y concisas. ¡Las buenas instrucciones son simples, completas y específicas!

Paso 13: ¡Ejecuta el experimento!

🎯 Objetivo: En este paso, haremos una primera prueba del experimento.

La doble flecha azul en la barra de herramientas es el botón de Ejecución rápida (Ctrl+Shift+W). Esto lanza el experimento en una ventana usando un número de sujeto y una ubicación de archivo de registro de prueba. Esto es útil principalmente durante el desarrollo.

La flecha verde simple es el botón Ejecutar en pantalla completa (Ctrl+R). Primero solicita un número de sujeto y archivo de registro, y si deseas ejecutar el experimento en pantalla completa o en una ventana. Esto es útil principalmente durante la recolección de datos.

¡Presiona uno de los dos botones para darle una prueba a tu experimento!

🏁 ¡Si el experimento se ejecuta, ya terminaste! Pero antes de terminar, revisemos dos puntos finales importantes, relacionados con la depuración y la selección del backend:

Depuración efectiva y comprensión de errores

Es normal encontrarse con errores al construir experimentos. Lee los errores cuidadosamente e intenta entender lo que significan. ¡Este es el Camino Verdadero hacia una depuración efectiva!

Figure 13 muestra un ejemplo de mensaje de error:

• El tipo de error es FStringError
• La descripción indica: “No se pudo evaluar la expresión f-string en el siguiente texto: gaze_{gaze_ceu}.png”
• El error ocurrió en la fase de preparación de los elementos gaze_cue
• El seguimiento es un mensaje de error de Python. Es una versión más técnica de la descripción anterior.

Figure 13. Un mensaje de error en OpenSesame.

Una vez que entiendas de dónde proviene el error, puedes intentar solucionarlo. En este ejemplo, el error resulta de un error tipográfico al definir el elemento gaze_cue en el Paso 6. gaze_{gaze_ceu}.png debería ser gaze_{gaze_cue}.png. ¡Fácil de arreglar!

Sincronización y selección de backend

En la pestaña 'Propiedades generales' del experimento (la pestaña que se abre al hacer clic en el nombre del experimento), puedes seleccionar un backend. El backend es la capa de software que controla la pantalla, los dispositivos de entrada, el sonido, etc. La mayoría de los experimentos funcionan con todos los backends, pero hay razones para preferir uno sobre otro, principalmente relacionadas con la sincronización. Actualmente hay cuatro backends:

• psycho es el predeterminado. Está basado en PsychoPy y proporciona una excelente sincronización (Peirce, 2007).
• xpyriment — está basado en Expyriment y también proporciona una excelente sincronización(Krause & Lindemann, 2013)
• legacy — es una opción de respaldo que funciona en más sistemas, pero ofrece una sincronización menos precisa
• osweb — ejecuta experimentos en un navegador (Mathôt & March, 2022)

Ver también:

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

Puntos clave

¡Has aprendido a construir un experimento simple pero completo!

• ✅ La estructura de un experimento normalmente se construye combinando elementos sequence y loop
• ✅ Las variables normalmente se definen en la tabla loop
• ✅ Los estímulos visuales sensibles al tiempo suelen presentarse con un sketchpad
• ✅ La retroalimentación al participante suele presentarse con elementos feedback
• ✅ El form_text_display es conveniente para presentar texto
• ✅ Las variables y expresiones pueden insertarse usando llaves. Ejemplo: {gaze_cue}
• ✅ Las expresiones Run-if se definen en una sequence y determinan qué elementos se ejecutan realmente: Ejemplo: correct == 0
• ✅ Siempre verifica el tiempo y los archivos de registro con una prueba exhaustiva antes de recoger los datos

Siguientes pasos

Ahora tienes una comprensión básica de OpenSesame. Esto es suficiente para construir muchos experimentos simples. Sin embargo, ¡puedes necesitar o querer aprender aún más! Aquí tienes próximos pasos recomendados:

• Aprende a construir experimentos junto a SigmundAI
• Aprende a usar código Python en tus experimentos
• Aprende a usar código JavaScript en tus experimentos en línea

Referencias