From 35461626af425593d5e7ce87b9ce179e6ff2e727 Mon Sep 17 00:00:00 2001 From: mhaeming Date: Wed, 17 Jan 2024 21:06:27 +0100 Subject: [PATCH 1/2] feat: dev expyriment version + uuid --- .gitignore | 2 + FlankerExperiment.py | 90 +++++++++++++++++++++++++++++--------------- requirements.txt | 4 +- 3 files changed, 63 insertions(+), 33 deletions(-) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..bc4a42f --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +*.xpd +*.xpe \ No newline at end of file diff --git a/FlankerExperiment.py b/FlankerExperiment.py index 967786b..aa86d2e 100644 --- a/FlankerExperiment.py +++ b/FlankerExperiment.py @@ -1,28 +1,32 @@ # import packages: from expyriment import design, control, stimuli, io, misc +from uuid import uuid4 import random # default settings: stimuli.defaults.textline_text_size = 50 stimuli.defaults.fixcross_line_width = 3 -stimuli.defaults.fixcross_size = (30,30) +stimuli.defaults.fixcross_size = (30, 30) control.set_develop_mode(True) io.defaults.outputfile_time_stamp = False control.defaults.open_gl = 2 - # function to create onset times: def mean(input_list): """Receives a list of integers as input and returns the mean of all entries""" - return (sum(input_list) / len(input_list)) + return sum(input_list) / len(input_list) + INSTRUCTIONS = "Press the according key for the middle symbol of the arrow array! Example: <<<<<, >><>> -> left, while >>>>>, <<><< -> right. After pressing any key, the experiment will start automatically after 5 seconds!" PAUSE_INTRO = "You now have completed the first one of two blocks. You have 5 minutes left, before the second one starts. The counter will refresh every minute." GOODBYE_TEXT = "Thanks for participating in this experiment, press any key to exit. In order to do something further, restart the menu.py file in a new terminal." + # function to construct the design: -def construct_design(exp, ): +def construct_design( + exp, +): """This function receives an expyriment object and adds the trials in blocks to it.""" left_congruent = ["congruent", "left", misc.constants.K_LEFT, "<<<<<"] right_congruent = ["congruent", "right", misc.constants.K_RIGHT, ">>>>>"] @@ -32,19 +36,24 @@ def construct_design(exp, ): for counter in [1, 2]: block = design.Block("Block") block.set_factor("Block", counter) - for kind in [left_congruent, right_congruent, left_incongruent, right_incongruent]: + for kind in [ + left_congruent, + right_congruent, + left_incongruent, + right_incongruent, + ]: t = design.Trial() t.set_factor("Condition", kind[0]) t.set_factor("Direction", kind[1]) t.set_factor("Key", kind[2]) t.set_factor("Block", counter) - s = stimuli.TextLine(text = kind[3], position = [0, 0]) + s = stimuli.TextLine(text=kind[3], position=[0, 0]) t.add_stimulus(s) - block.add_trial(t, copies = 6) + block.add_trial(t, copies=6) block.shuffle_trials() exp.add_block(block) - + def conduct_experiment(exp, blankscreen, fixcross, response_keys): """This function conducts the experiment according to the trial order constructe by the previous function.""" random.seed() @@ -52,31 +61,31 @@ def conduct_experiment(exp, blankscreen, fixcross, response_keys): for block in exp.blocks: # generate inter_trial_intervals and set an index: inter_trial_intervals = [8, 9, 10, 11, 12, 13, 14] - onset = random.choices(inter_trial_intervals, k = 23) + onset = random.choices(inter_trial_intervals, k=23) while mean(onset) != 12: - onset = random.choices(inter_trial_intervals, k = 23) + onset = random.choices(inter_trial_intervals, k=23) onset.insert(0, 0) index = 0 - + # show instructions: stimuli.TextScreen("Instructions", INSTRUCTIONS).present() exp.keyboard.wait() blankscreen.present() exp.clock.wait_seconds(5) - + # start the trials: for trial in block.trials: # present fixcross exp.clock.wait_seconds(onset[index] - 1) - fixcross.present(clear = False, update = True) + fixcross.present(clear=False, update=True) exp.clock.wait(900) blankscreen.present() exp.clock.wait(100 - trial.stimuli[0].preload()) - + # present stimulus, take button & time and present blankscreen thereafter trial.stimuli[0].present() - button, rt = exp.keyboard.wait(keys = response_keys) - blankscreen.present() # feedback for the participant that trial was successful + button, rt = exp.keyboard.wait(keys=response_keys) + blankscreen.present() # feedback for the participant that trial was successful # transfer the data and update index: response_correct = int((button == trial.get_factor("Key")) == True) @@ -84,43 +93,62 @@ def conduct_experiment(exp, blankscreen, fixcross, response_keys): variance = 1 else: variance = 2 - exp.data.add([response_correct, variance, trial.get_factor("Condition"), sum(onset[:(index + 1)]), rt, block.get_factor("Block")]) + exp.data.add( + [ + response_correct, + variance, + trial.get_factor("Condition"), + sum(onset[: (index + 1)]), + rt, + block.get_factor("Block"), + ] + ) index += 1 - + # 5-minute-waiting-perios after the first block (with minute counter) if block.get_factor("Block") == 1: stimuli.TextScreen("Pause", PAUSE_INTRO).present() exp.clock.wait_minutes(1) - + for minute in [4, 3, 2, 1]: - stimuli.TextScreen("Pause", "You now have " +str(minute) + " minute(s) left.").present() + stimuli.TextScreen( + "Pause", "You now have " + str(minute) + " minute(s) left." + ).present() exp.clock.wait_minutes(1) - def main(): """Main function: calls upon collaborating functions and coordinates the experiment.""" # Create and initialize an experiment: exp = design.Experiment("Flanker Task") control.initialize(exp) - + # Define and preload standard stimuli: fixcross = stimuli.FixCross() fixcross.preload() blankscreen = stimuli.BlankScreen() blankscreen.preload() - + # left and right arrow keys for responses: response_keys = [misc.constants.K_LEFT, misc.constants.K_RIGHT] - - construct_design(exp) # function call -> see function further up - + + construct_design(exp) # function call -> see function further up + # define variable names for collecting data - exp.data_variable_names = ["Response", "StimVar", "Condition", "Onset", "RT", "Block"] - + exp.data_variable_names = [ + "Response", + "StimVar", + "Condition", + "Onset", + "RT", + "Block", + ] + # conduct the whole experiment: - control.start() - conduct_experiment(exp, blankscreen, fixcross, response_keys) # function call -> see further up + control.start(subject_id=uuid4().int) + conduct_experiment( + exp, blankscreen, fixcross, response_keys + ) # function call -> see further up stimuli.TextScreen("That's it", GOODBYE_TEXT).present() exp.keyboard.wait() control.end() @@ -128,4 +156,4 @@ def main(): # not yet sure, whether necessary: if __name__ == "__main__": - main() \ No newline at end of file + main() diff --git a/requirements.txt b/requirements.txt index c0563c3..6a79103 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,7 +1,7 @@ numpy >= 1.19.5 matplotlib >= 3.3.4 pandas >= 1.1.5 -expyriment +expyriment @ git+https://github.com/expyriment/expyriment.git plotnine -sklearn +scikit-learn panel From 98460160e157f4c7a5990caf34e1b6b44c47f5be Mon Sep 17 00:00:00 2001 From: mhaeming Date: Mon, 5 Feb 2024 09:01:22 +0100 Subject: [PATCH 2/2] upload notebook + update gitignore --- .gitignore | 129 +++++++ analysis/MiCS_GroupProject_FlankerTask.ipynb | 368 +++++++++++++++++++ requirements.txt | 2 + 3 files changed, 499 insertions(+) create mode 100644 analysis/MiCS_GroupProject_FlankerTask.ipynb diff --git a/.gitignore b/.gitignore index bc4a42f..1a5df9b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,131 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[co] +*$py.class + + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# Expyriment files *.xpd *.xpe \ No newline at end of file diff --git a/analysis/MiCS_GroupProject_FlankerTask.ipynb b/analysis/MiCS_GroupProject_FlankerTask.ipynb new file mode 100644 index 0000000..7b6a9a9 --- /dev/null +++ b/analysis/MiCS_GroupProject_FlankerTask.ipynb @@ -0,0 +1,368 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "language": "python", + "display_name": "Python 3 (ipykernel)" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Flanker\n", + "\n", + "This Python notebook serves as a template for your group project for the course \"Modeling in Cognitive Science\".\n", + "\n", + "This is the practical part of the group project where you get to implement the computational modeling workflow. In this part, you are expected to:\n", + "\n", + "\n", + "* Implement at least two computational models relevant for your hypothesis. *(3 points)*\n", + "* Simulate behavior from the two models. *(3 points)*\n", + "* Implement a procedure for fitting the models to data. *(4 points)*\n", + "* Implement a procedure for parameter recovery. *(5 points)*\n", + "* (Implement a procedure for model recovery.) *(optional; 2 bonus points)*\n", + "* Implement a model comparison. *(5 points)*.\n", + "\n", + "You can gain a total of 20 points for the practical part of the group project.\n", + "\n", + "**Note:** *Some of the exercises below (e.g. Model Simulation) rely on code from previous exercises (e.g., Model Implementation). In such cases, you are encouraged to rely on functions implemented for previous exercises. That is, you don't have to produce redundant code.*\n", + "\n" + ], + "metadata": { + "id": "K8D2mabhtCeh" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Model Implementation *(3 points)*\n", + "\n", + "For this exercise you should:\n", + "\n", + "* Implement and simulate data from two* models that are suitable to test your hypothesis. *(3 points)*\n", + "\n", + "*You may implement more than two models if you wish. However, two models are sufficient for this group project.\n", + "\n", + "Make sure to comment your code and provide an explanation for each code block in a preceding text block.\n" + ], + "metadata": { + "id": "HceMyA8DtIZ3" + } + }, + { + "cell_type": "code", + "source": [ + "# necessary imports\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import arviz as az\n", + "from scipy.stats import norm\n" + ], + "metadata": { + "id": "isMmbQsKwZ_z", + "ExecuteTime": { + "end_time": "2024-02-01T15:18:34.225880800Z", + "start_time": "2024-02-01T15:18:32.119521900Z" + } + }, + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "code", + "outputs": [], + "source": [ + "# class for drift diffusion model\n", + "class Spotlight_DDM():\n", + " def __init__(self, name):\n", + " self.name = name # to distinguish models properly\n", + " \n", + "\n", + " def __call__(self, p_total,\n", + " r,\n", + " sd_a,\n", + " threshold,\n", + " starting_point,\n", + " noise_std,\n", + " non_decision_time,\n", + " dt,\n", + " max_time):\n", + " \"\"\"\n", + " Simulates the Drift Diffusion Model for one run with fixed time increments to match evidence points.\n", + " \n", + " Arguments:\n", + " - p_total: perceptual input for target and distractor flankers of shape [target, distractors] (values can be -1 (left) or 1(right))\n", + " - sd_a: standard deviation of attention allocation distribution (spotlight width)\n", + " - r: temporal decay of the standard deviation of attention (spotlight narrowing term)\n", + " - threshold: evidence needed to reach a decision\n", + " - starting_point: initial condition of the evidence\n", + " - noise_std: standard deviation of the noise term\n", + " - non_decision_time: time not included in the evidence accumulation process\n", + " - dt: time increment\n", + " - max_time: maximum simulation time\n", + " \n", + " Returns:\n", + " - decision_time: the time taken to reach a decision\n", + " - evidence_over_time: the evidence accumulated over time\n", + " - decision: 1 if the decision boundary reached is the upper threshold, -1 if lower\n", + " \"\"\"\n", + " # Initialize evidence accumulation process\n", + " time = non_decision_time\n", + " evidence = starting_point\n", + " evidence_over_time = [evidence]\n", + " \n", + " # Run the simulation until a decision boundary is reached or max time is exceeded\n", + " while time < max_time:\n", + " # Increment the evidence by the drift and some noise (drift rate is a time-varying evidence drift rate)\n", + " if sd_a >= 0.001 + r: # only decay the attention standard deviation until a certain limit\n", + " sd_a = sd_a - r\n", + " attention_outer = 2 * norm(loc = 0, scale = sd_a).cdf(-0.5)\n", + " drift_rate = 2 * attention_outer * p_total[1] + (1 - attention_outer) * p_total[0] # compute time_varying evidence drift rate\n", + " evidence += drift_rate * dt + np.sqrt(dt) * np.random.normal(0, noise_std)\n", + " evidence_over_time.append(evidence)\n", + " time += dt # Increment the time\n", + " \n", + " # Check if the evidence has reached either threshold\n", + " if evidence >= threshold:\n", + " return time, evidence_over_time, 1 # Decision made for the upper threshold\n", + " elif evidence <= 0:\n", + " return time, evidence_over_time, -1 # Decision made for the lower threshold\n", + " \n", + " # If no decision has been made by max_time, return the current state\n", + " return time, evidence_over_time, 0" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-02-01T15:18:34.252136500Z", + "start_time": "2024-02-01T15:18:34.236488600Z" + } + }, + "execution_count": 2 + }, + { + "cell_type": "code", + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ddm = Spotlight_DDM(\"my_ddm\")\n", + "p_total = [1, -1] # incongruent trial with target pointing to the right and distractors pointing left\n", + "r = 0.2 # attention narrowing parameter\n", + "sd_a = 1 # initial attention standard deviation\n", + "a = 2 # threshold\n", + "z = a/2 # starting point (between 0 and threshold a)\n", + "sigma = 1 # standard deviation of noise\n", + "t0 = 0 # non-decision time\n", + "dt = 0.01 # integration constant\n", + "max_time = 1000 # maximum number of simulated seconds\n", + "\n", + "decision_time, evidence_over_time, decision = ddm(p_total = p_total,\n", + " r = r,\n", + " sd_a = sd_a,\n", + " threshold = a,\n", + " starting_point = z,\n", + " noise_std = sigma,\n", + " non_decision_time = t0,\n", + " dt = dt,\n", + " max_time = max_time)\n", + "\n", + "plt.plot(np.linspace(t0+0, t0+decision_time, len(evidence_over_time)), evidence_over_time)\n", + "plt.axhline(y=a, color='green', linestyle='--')\n", + "plt.axhline(y=0, color='red', linestyle='--')\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Evidence')\n", + "plt.title(f'Drift Diffusion Model (Decision: {\"Right\" if decision == 1 else \"Left\" if decision == 0 else \"None\"})')\n", + "plt.show()" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2024-02-01T15:19:57.627116200Z", + "start_time": "2024-02-01T15:19:57.378731600Z" + } + }, + "execution_count": 9 + }, + { + "cell_type": "markdown", + "source": [ + "*The targeted hypothesis is that after the multiple trials where the flanker pointed in a certain direction, the participant is biased towards or against this flanker direction and the the offset (the starting point z) shifts towards one of the decision boundaries.*" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Model Simulation *(3 points)*\n", + "\n", + "For this exercise you should:\n", + "\n", + "* Simulate data from both models for a single set of parameters. The simulation should mimic the experiment you are trying to model. *(2 points)*\n", + "\n", + "* Plot the simulated behavior of both models. *(1 point)*\n", + "\n", + "Make sure to comment your code and provide an explanation for each code block in a preceding text block.\n" + ], + "metadata": { + "id": "twTHrAfL2PC_" + } + }, + { + "cell_type": "code", + "source": [ + "# YOUR MODEL SIMULATION CODE GOES HERE" + ], + "metadata": { + "id": "XIk8efpKv-m-" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Parameter Fitting *(4 points)*\n", + "\n", + "For this exercise you should:\n", + "\n", + "* Set up a suitable parameter search space *(1 point)*\n", + "\n", + "* Implement a procedure to evaluate the fit of a model based on data *(2 points)*\n", + "\n", + "* Implement a procedure for searching the parameter space. *(1 point)*\n", + "\n", + "Make sure to comment your code and provide an explanation for each code block in a preceding text block.\n", + "\n" + ], + "metadata": { + "id": "2VxwTW9LwnvJ" + } + }, + { + "cell_type": "code", + "source": [ + "# YOUR PARAMETER FITTING CODE GOES HERE" + ], + "metadata": { + "id": "K5OKVYszx7tQ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Parameter Recovery *(5 points)*\n", + "\n", + "For this exercise you should:\n", + "\n", + "* Set up a suitable space of parameters relevant for parameter recovery *(1 point)*\n", + "\n", + "* Use the functions above to generate behavior from a models, for a given set of (randomly sampled) parameters, and then fit the model to its generated data. Make sure to evaluate the parameter fit in a quantiative manner. *(3 points)*\n", + "\n", + "* Plot the parameter recovery results for both models. *(1 point)*\n", + "\n", + "Make sure to comment your code and provide an explanation for each code block in a preceding text block.\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "ueZgrw_ByFsF" + } + }, + { + "cell_type": "code", + "source": [ + "# YOUR PARAMETER RECOVERY CODE GOES HERE" + ], + "metadata": { + "id": "bLdarAD8yXwN" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## *Optional*: Model Recovery *(2 bonus points)*\n", + "\n", + "In this bonus exercise, you may examine model reovery. The bonus points count towards your total group project points. That is, you may accumlate up to 22 points in the practical part of the group project.\n", + "\n", + "Make sure to comment your code and provide an explanation for each code block in a preceding text block.\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "naQNlDBfzjnG" + } + }, + { + "cell_type": "code", + "source": [ + "# YOUR MODEL RECOVERY CODE GOES HERE" + ], + "metadata": { + "id": "tIR51ujwziTM" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Model Comparison *(5 points)*\n", + "\n", + "For this exercise you should:\n", + "\n", + "* Load and (potentially) preprocess the experimental data. (1 point)\n", + "\n", + "* Fit the two models to the data. *(1 point)*\n", + "\n", + "* Evaluate which model performs better, taking into account fit and model complexity. *(2 points)*\n", + "\n", + "* Plot the behavior of the winning model against the data. *(1 point)**\n", + "\n", + "Make sure to comment your code and provide an explanation for each code block in a preceding text block.\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "id": "-q4dfJ7O0BpW" + } + }, + { + "cell_type": "code", + "source": [ + "# YOUR MODEL COMPARISON CODE GOES HERE" + ], + "metadata": { + "id": "8wAGI-kd1yRb" + }, + "execution_count": null, + "outputs": [] + } + ] +} diff --git a/requirements.txt b/requirements.txt index 6a79103..47dc774 100644 --- a/requirements.txt +++ b/requirements.txt @@ -5,3 +5,5 @@ expyriment @ git+https://github.com/expyriment/expyriment.git plotnine scikit-learn panel +jupyter +arviz \ No newline at end of file