{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "9cefe689-fab2-46cd-b8d4-1ac9eec78387", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict_keys(['type', 'name', 'database', 'data'])\n", "num participants: 67\n" ] } ], "source": [ "import numpy as np\n", "import json\n", "import pandas as pd\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "\n", "with open(\"divided_attention_club.json\", \"r\", encoding=\"utf-8\") as f:\n", " data = json.load(f)\n", "\n", "relevant_data_index = data[2]\n", "print(relevant_data_index.keys())\n", "real_data = relevant_data_index['data']\n", "type(real_data)\n", "print('num participants:', len(real_data))" ] }, { "cell_type": "code", "execution_count": 2, "id": "9cf1065e-75d8-4ed7-9172-842a01260f47", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Element 17 keys:\n", "dict_keys(['id', 'participant_id', 'start_time', 'end_time', 'notif_block2_condition', 'notif_block3_condition', 'block1_symbols', 'block2_symbols', 'block3_symbols', 'notif_block2_animals', 'notif_block3_animals', 'json_data'])\n" ] } ], "source": [ "print(f\"\\nElement {17} keys:\")\n", "print(real_data[17].keys())" ] }, { "cell_type": "code", "execution_count": 3, "id": "d0e232a2-48ac-407f-898a-4895cb4409c6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict_keys(['task', 'block', 'trial_in_block', 'phase', 'symbol', 'correct_key', 'notification_flag', 'notification_sentence', 'rt', 'response', 'trial_type', 'trial_index', 'plugin_version', 'time_elapsed', 'participantIndex', 'participant_id', 'vp_code', 'notif_block2_condition', 'notif_block3_condition', 'block1_symbols', 'block2_symbols', 'block3_symbols', 'notif_block2_animals', 'notif_block3_animals', 'demo_age_range', 'demo_gender', 'demo_german_level', 'demo_education', 'demo_program', 'demo_semester', 'demo_vision', 'demo_handedness', 'demo_screentime'])\n", "Anzahl Trials: 878\n", "irregular\n", "True\n" ] } ], "source": [ "# example trial for one participant\n", "data_one_participant = real_data[17]['json_data']\n", "data_one_participant = json.loads(data_one_participant)\n", "print (data_one_participant[66].keys()) # only one trial\n", "num_trials = len(data_one_participant)\n", "print(\"number of trials:\", num_trials)\n", "print (data_one_participant[67]['notif_block2_condition'])\n", "print(data_one_participant[73]['correct'])" ] }, { "cell_type": "code", "execution_count": 4, "id": "fd098c7c-213e-4dd7-9576-01257b308863", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Anzahl trials ohne push notifications alle participants mit regulärer Block zuerst: 2688\n", "Anzahl trials ohne push notifications alle participants mit irregulärer Block zuerst: 3744\n", "Anteil korrekter trials ohne push notification participants mit regulärem Block zuerst: 0.7827380952380952\n", "Anteil korrekter trials ohne push notification participants mit irregulärem Block zuerst: 0.7123397435897436\n", "Anzahl trials reguläre push notifications alle participants mit regulärem Block zuerst: 2688\n", "Anzahl trials reguläre push notifications alle participants mit irregulärem Block zuerst: 3744\n", "Anteil korrekter trials reguläre push notifications participants mit regulärem Block zuerst: 0.7819940476190477\n", "Anteil korrekter trials reguläre push notifications participants mit irregulärem Block zuerst: 0.7692307692307693\n", "Anzahl trials irreguläre push notifications participants mit regulärem Block zuerst: 2688\n", "Anzahl trials irreguläre push notifications participants mit irregulärem Block zuerst: 3744\n", "Anteil korrekter trials irreguläre notification participants mit regulärem Block zuerst: 0.7745535714285714\n", "Anteil korrekter trials irreguläre notification participants mit irregulärem Block zuerst: 0.7529380341880342\n", "Anzahl personen bei denen im dritten Block reguläre push notifications waren: 39\n", "nach Blockreihenfolge gewichteter Anteil richtiger trials ohne push notifications: 0.7475389194139195\n", "nach Blockreihenfolge gewichteter Anteil richtiger trials reguläre push notifications: 0.7756124084249085\n", "nach Blockreihenfolge gewichteter Anteil richtiger trials irreguläre push notifications: 0.7637458028083028\n", "Anteil korrekter Tiernamen reguläre Blocks: 0.4141791044776119\n", "Anteil korrekter Tiernamen irreguläre Blocks: 0.4201492537313433\n" ] } ], "source": [ "# calculate percentage of correct trials across all participants and trials\n", "# 96 trials per block per participant: 0-95 = no notification, 96-191 = second block, > 191 = third block\n", "# regular_first at the end means \"of the participants who had regular notifications in the second block\n", "num_trials_no_notifications_total_regular_first = 0 \n", "# irregular_first at the end means \" of the participants who had irregular notifications in the second block\n", "num_trials_no_notifications_total_irregular_first = 0\n", "num_trials_regular_notifications_total_regular_first = 0\n", "num_trials_regular_notifications_total_irregular_first = 0\n", "num_trials_irregular_notifications_total_regular_first = 0\n", "num_trials_irregular_notifications_total_irregular_first = 0\n", "num_correct_trials_no_notifications_total_regular_first = 0\n", "num_correct_trials_no_notifications_total_irregular_first = 0\n", "num_correct_trials_regular_notifications_total_regular_first = 0\n", "num_correct_trials_regular_notifications_total_irregular_first = 0\n", "num_correct_trials_irregular_notifications_total_regular_first = 0\n", "num_correct_trials_irregular_notifications_total_irregular_first = 0\n", "\n", "sum_prop_correct_animals_regular = 0\n", "num_animal_recognition_regular = 0\n", "sum_prop_correct_animals_irregular = 0\n", "num_animal_recognition_irregular = 0\n", "\n", "treshold_second_block = 96\n", "treshold_third_block = 96 * 2\n", "num_participants_with_third_block_regular = 0\n", "\n", "# for calculating the standard deviation\n", "participants_no = []\n", "participants_reg = []\n", "participants_irreg = []\n", "\n", "for participant in real_data: # iteration through all participants\n", " # for calculating the standard deviation\n", " correct_no = 0\n", " trials_no = 0\n", " correct_reg = 0\n", " trials_reg = 0\n", " correct_irreg = 0\n", " trials_irreg = 0\n", " \n", " counter_trials = 0\n", " counter_real_trials = 0\n", " trials = json.loads(participant['json_data']) # all trials of the participant\n", " counter_animal_trials = 0\n", " for trial in trials: # iteration through all trials\n", " category = \"regular_first\"\n", " if (trial['notif_block3_condition'] == 'regular'):\n", " category = \"irregular_first\"\n", " if (counter_trials == 0):\n", " if (trial['notif_block3_condition'] == 'regular'):\n", " num_participants_with_third_block_regular += 1\n", " counter_trials += 1\n", " if ('correct' in trial):\n", " # check which condition the current trial is\n", " current_block_condition = 'no_notifications'\n", " if (counter_real_trials >= treshold_second_block): # 2nd or 3rd block\n", " if (counter_real_trials >= treshold_third_block): # 3rd block\n", " if (trial['notif_block3_condition'] == 'irregular'):\n", " current_block_condition = 'irregular'\n", " else:\n", " current_block_condition = 'regular'\n", " else: # 2. Block\n", " if (trial['notif_block2_condition'] == 'irregular'):\n", " current_block_condition = 'irregular'\n", " else:\n", " current_block_condition = 'regular'\n", " \n", " # add value to respective value (1 if correct, 0 if incorrect), check previously whether correct_key exists\n", " # if correct_trial: add 1 to number of trials\n", " if (current_block_condition == 'no_notifications'):\n", " trials_no += 1\n", " if trial['correct']:\n", " correct_no += 1\n", " if (category == \"regular_first\"):\n", " num_trials_no_notifications_total_regular_first += 1\n", " else:\n", " num_trials_no_notifications_total_irregular_first += 1\n", " if (trial['correct']):\n", " if (category == \"regular_first\"):\n", " num_correct_trials_no_notifications_total_regular_first += 1\n", " else:\n", " num_correct_trials_no_notifications_total_irregular_first += 1\n", " elif (current_block_condition == 'regular'):\n", " trials_reg += 1\n", " if trial['correct']:\n", " correct_reg += 1\n", " if (category == \"regular_first\"):\n", " num_trials_regular_notifications_total_regular_first += 1\n", " else:\n", " num_trials_regular_notifications_total_irregular_first += 1\n", " if (trial['correct']):\n", " if (category == \"regular_first\"):\n", " num_correct_trials_regular_notifications_total_regular_first += 1\n", " else:\n", " num_correct_trials_regular_notifications_total_irregular_first += 1\n", " else: # irregular\n", " trials_irreg += 1\n", " if trial['correct']:\n", " correct_irreg += 1\n", " if (category == \"regular_first\"):\n", " num_trials_irregular_notifications_total_regular_first += 1\n", " else:\n", " num_trials_irregular_notifications_total_irregular_first += 1\n", " if (trial['correct']):\n", " if (category == \"regular_first\"):\n", " num_correct_trials_irregular_notifications_total_regular_first += 1\n", " else:\n", " num_correct_trials_irregular_notifications_total_irregular_first += 1\n", " counter_real_trials += 1\n", " if ('selected_animals' in trial):\n", " current_block_condition = 'no_notifications'\n", " if (counter_animal_trials == 1): # 3rd block\n", " if (trial['notif_block3_condition'] == 'irregular'):\n", " current_block_condition = 'irregular'\n", " else:\n", " current_block_condition = 'regular'\n", " else: # 2. Block\n", " if (trial['notif_block2_condition'] == 'irregular'):\n", " current_block_condition = 'irregular'\n", " else:\n", " current_block_condition = 'regular'\n", " selected = trial['selected_animals']\n", " notified = trial['notified_animals']\n", " correct_selected = set(selected) & set(notified)\n", " proportion_correct = len(correct_selected) / len(notified)\n", " if (current_block_condition == 'regular'):\n", " sum_prop_correct_animals_regular += proportion_correct\n", " num_animal_recognition_regular += 1\n", " else:\n", " sum_prop_correct_animals_irregular += proportion_correct\n", " num_animal_recognition_irregular += 1\n", " counter_animal_trials += 1\n", "\n", " participants_no.append(correct_no / trials_no)\n", " participants_reg.append(correct_reg / trials_reg)\n", " participants_irreg.append(correct_irreg / trials_irreg)\n", "\n", "means = [\n", " 0.74, # value out of Descriptive Data analysis_correct.ipynb -> previous value was weighted by distribution of participants concerning block order, now not anymore\n", " # np.mean(participants_no), # old weighted value\n", " np.mean(participants_reg), # weighted value, but the same as the non-weighted\n", " np.mean(participants_irreg) # weighted value, but the same as the non-weighted\n", "]\n", "stds = [ # standard deviation\n", " np.std(participants_no, ddof=1),\n", " np.std(participants_reg, ddof=1),\n", " np.std(participants_irreg, ddof=1)\n", "]\n", "\n", "print(\"number of trials without push notifications of all participants with regular block first: \",\n", " num_trials_no_notifications_total_regular_first)\n", "print(\"number of trials without push notifications of all participants with irregular block first: \",\n", " num_trials_no_notifications_total_irregular_first)\n", "print(\"percentage of correct trials without push notification of all participants with regular block first: \",\n", " num_correct_trials_no_notifications_total_regular_first/num_trials_no_notifications_total_regular_first)\n", "print(\"percentage of correct trials without push notification of all participants with irregular block first: \",\n", " num_correct_trials_no_notifications_total_irregular_first/num_trials_no_notifications_total_irregular_first)\n", "print(\"number of trials with regular push notifications of all participants with regular block first: \",\n", " num_trials_regular_notifications_total_regular_first)\n", "print(\"number trials with regular push notifications of all participants with irregular block first: \",\n", " num_trials_regular_notifications_total_irregular_first)\n", "print(\"percentage of correct trials with regular push notifications of all participants with regular Block first: \",\n", " num_correct_trials_regular_notifications_total_regular_first/num_trials_regular_notifications_total_regular_first)\n", "print(\"percentage of correct trials with regular push notifications of all participants with irregular block first: \",\n", " num_correct_trials_regular_notifications_total_irregular_first/num_trials_regular_notifications_total_irregular_first)\n", "print(\"number of trials with irregular push notifications of all participants with regular block first: \",\n", " num_trials_irregular_notifications_total_regular_first)\n", "print(\"number of trials with irregular push notifications of all participants with irregular block first: \",\n", " num_trials_irregular_notifications_total_irregular_first)\n", "print(\"percentage of correct trials with irregular notification of all participants with regular block first: \",\n", " num_correct_trials_irregular_notifications_total_regular_first/num_trials_irregular_notifications_total_regular_first)\n", "print(\"percentage of correkt trials irregular notifications of all participants with irregular block first: \",\n", " num_correct_trials_irregular_notifications_total_irregular_first/num_trials_irregular_notifications_total_irregular_first)\n", "\n", "# weight according to block order\n", "weighted_perc_no = (num_correct_trials_no_notifications_total_regular_first/num_trials_no_notifications_total_regular_first + num_correct_trials_no_notifications_total_irregular_first/num_trials_no_notifications_total_irregular_first) / 2\n", "print(\"percentage of correct trials without notifications weighted by block order: \", weighted_perc_no)\n", "weighted_perc_reg = (num_correct_trials_regular_notifications_total_regular_first/num_trials_regular_notifications_total_regular_first + num_correct_trials_regular_notifications_total_irregular_first/num_trials_regular_notifications_total_irregular_first) / 2\n", "print(\"percentage of correct trials of regular notifications weighted by block order: \", weighted_perc_reg)\n", "weighted_perc_irreg = (num_correct_trials_irregular_notifications_total_regular_first/num_trials_irregular_notifications_total_regular_first + num_correct_trials_irregular_notifications_total_irregular_first/num_trials_irregular_notifications_total_irregular_first) / 2\n", "print(\"percentage of correct trials of irregular notifications weighted by block order: \", weighted_perc_irreg) \n", "\n", "print(\"percentage correct animal names regular blocks: \", sum_prop_correct_animals_regular/num_animal_recognition_regular)\n", "print(\"percentage correct animal names irregular blocks: \", sum_prop_correct_animals_irregular/num_animal_recognition_irregular)" ] }, { "cell_type": "code", "execution_count": 5, "id": "e99a0f90-0d23-4561-97f2-9416107d7af8", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "conditions = [\n", " \"no notifications\",\n", " \"regular\",\n", " \"irregular\"\n", "]\n", "\n", "proportions = [weighted_perc_no, weighted_perc_reg, weighted_perc_irreg]\n", "\n", "colors = [\"gray\", \"steelblue\", \"orange\"]\n", "\n", "plt.figure()\n", "bars = plt.bar(conditions, means, yerr=stds, capsize=6, color=colors)\n", "\n", "plt.ylabel(\"average percentage of correct trials\")\n", "plt.title(\"performance for each block condition\")\n", "plt.ylim(1/3, 1) # I chose 1/3, because this would be the expected value, if participants would guess\n", "\n", "for bar, value in zip(bars, means):\n", " plt.text(bar.get_x() + bar.get_width()/2 + 0.1, bar.get_height(),\n", " f\"{value:.2f}\", ha='center', va='bottom')\n", "\n", "plt.savefig(\"performance_block_conditions.png\", dpi=300, bbox_inches=\"tight\")\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "85067dd6-423c-4748-8a3c-62eecf8ae5d0", "metadata": {}, "outputs": [], "source": [ "# calculate percentage correct trials across all participants and trials per condition\n", "# 96 trials per Block per participant: 0-95 = no notification, 96-191 = 2nd block, > 191 = 3rd block" ] }, { "cell_type": "code", "execution_count": null, "id": "7be980c3-4b89-4ae4-a00d-3a45c2a34169", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "used trials: 19234\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "num_trials_no_notifications_total_regular_first = 0 \n", "num_trials_no_notifications_total_irregular_first = 0\n", "num_trials_regular_notifications_total_regular_first = 0\n", "num_trials_regular_notifications_total_irregular_first = 0\n", "num_trials_irregular_notifications_total_regular_first = 0\n", "num_trials_irregular_notifications_total_irregular_first = 0\n", "sum_reaction_time_no_notifications_total_regular_first = 0\n", "sum_reaction_time_no_notifications_total_irregular_first = 0\n", "sum_reaction_time_regular_notifications_total_regular_first = 0\n", "sum_reaction_time_regular_notifications_total_irregular_first = 0\n", "sum_reaction_time_irregular_notifications_total_regular_first = 0\n", "sum_reaction_time_irregular_notifications_total_irregular_first = 0\n", "\n", "treshold_second_block = 96\n", "treshold_third_block = 96 * 2\n", "num_participants_with_third_block_regular = 0\n", "\n", "participant_rt_no = []\n", "participant_rt_reg = []\n", "participant_rt_irreg = []\n", "\n", "used_trials = 0\n", "\n", "for participant in real_data: # iteration through all participants\n", " sum_rt_no_participant = 0\n", " sum_rt_reg_participant = 0\n", " sum_rt_irreg_participant = 0\n", "\n", " num_trials_no_participant = 0\n", " num_trials_reg_participant = 0\n", " num_trials_irreg_participant = 0\n", " \n", " counter_trials = 0\n", " counter_real_trials = 0\n", " trials = json.loads(participant['json_data']) # all trials of the participant\n", " for trial in trials: # iteration through all trials\n", " if ('correct' in trial):\n", " if ('rt' in trial and trial['rt'] is not None):\n", "\n", " used_trials += 1\n", " \n", " reaction_time = trial['rt']\n", " category = \"regular_first\"\n", " if (trial['notif_block3_condition'] == 'regular'):\n", " category = \"irregular_first\"\n", " if (counter_trials == 0):\n", " if (trial['notif_block3_condition'] == 'regular'):\n", " num_participants_with_third_block_regular += 1\n", " counter_trials += 1\n", " # check which condition this trial is\n", " \"\"\"\n", " current_block_condition = 'no_notifications'\n", " # alternative Zeile: \n", " # if (trial['block'] == 2 or trial['block'] == 3 ):\n", " if (counter_real_trials >= treshold_second_block): # 2. oder 3. Block\n", " #alternative Zeile: \n", " # if (trial['block'] == 3)\n", " if (counter_real_trials >= treshold_third_block): # 3. Block\n", " if (trial['notif_block3_condition'] == 'irregular'):\n", " current_block_condition = 'irregular'\n", " else:\n", " current_block_condition = 'regular'\n", " else: # 2. Block\n", " if (trial['notif_block2_condition'] == 'irregular'):\n", " current_block_condition = 'irregular'\n", " else:\n", " current_block_condition = 'regular'\n", " \"\"\"\n", " block = trial.get('block')\n", " if block == 1:\n", " current_block_condition = 'no_notifications'\n", " elif block == 2:\n", " current_block_condition = trial.get('notif_block2_condition')\n", " elif block == 3:\n", " current_block_condition = trial.get('notif_block3_condition')\n", " else:\n", " continue\n", " \n", " if (current_block_condition == 'no_notifications'):\n", " if (category == \"regular_first\"):\n", " num_trials_no_notifications_total_regular_first += 1\n", " else:\n", " num_trials_no_notifications_total_irregular_first += 1\n", " num_trials_no_participant += 1\n", " sum_rt_no_participant += reaction_time\n", " if (category == \"regular_first\"):\n", " sum_reaction_time_no_notifications_total_regular_first += reaction_time\n", " else:\n", " sum_reaction_time_no_notifications_total_irregular_first += reaction_time\n", " elif (current_block_condition == 'regular'):\n", " if (category == \"regular_first\"):\n", " num_trials_regular_notifications_total_regular_first += 1\n", " else:\n", " num_trials_regular_notifications_total_irregular_first += 1\n", " num_trials_reg_participant += 1\n", " sum_rt_reg_participant += reaction_time\n", " if (category == \"regular_first\"):\n", " sum_reaction_time_regular_notifications_total_regular_first += reaction_time\n", " else:\n", " sum_reaction_time_regular_notifications_total_irregular_first += reaction_time\n", " else: # irregular\n", " if (category == \"regular_first\"):\n", " num_trials_irregular_notifications_total_regular_first += 1\n", " else:\n", " num_trials_irregular_notifications_total_irregular_first += 1\n", " num_trials_irreg_participant += 1\n", " sum_rt_irreg_participant += reaction_time\n", " if (category == \"regular_first\"):\n", " sum_reaction_time_irregular_notifications_total_regular_first += reaction_time\n", " else:\n", " sum_reaction_time_irregular_notifications_total_irregular_first += reaction_time\n", " counter_real_trials += 1\n", "\n", " if num_trials_no_participant > 0:\n", " participant_rt_no.append(sum_rt_no_participant / num_trials_no_participant)\n", " if num_trials_reg_participant > 0:\n", " participant_rt_reg.append(sum_rt_reg_participant / num_trials_reg_participant)\n", " if num_trials_irreg_participant > 0:\n", " participant_rt_irreg.append(sum_rt_irreg_participant / num_trials_irreg_participant)\n", "\"\"\"\n", "means = [\n", " np.mean(participant_rt_no),\n", " np.mean(participant_rt_reg),\n", " np.mean(participant_rt_irreg)\n", "]\n", "stds = [\n", " np.std(participant_rt_no, ddof=1),\n", " np.std(participant_rt_reg, ddof=1),\n", " np.std(participant_rt_irreg, ddof=1)\n", "]\n", "\"\"\"\n", "\n", "means = [463, 450, 445] # values from Descriptive Data analysis_correct.ipynb (not weighted according to order)\n", "stds = [184, 189, 160] # values from Descriptive Data analysis_correct.ipynb (not weighted according to order)\n", "\n", "print(\"used trials: \", used_trials)\n", "\n", "\"\"\" \n", "print(\"Anzahl trials ohne push notifications alle participants mit regulärer Block zuerst: \",\n", " num_trials_no_notifications_total_regular_first)\n", "print(\"Anzahl trials ohne push notifications alle participants mit irregulärer Block zuerst: \",\n", " num_trials_no_notifications_total_irregular_first)\n", "print(\"durchschnittliche Reaktionszeit ohne push notification participants mit regulärem Block zuerst: \",\n", " sum_reaction_time_no_notifications_total_regular_first/num_trials_no_notifications_total_regular_first)\n", "print(\"durchschnittliche Reaktionszeit ohne push notification participants mit irregulärem Block zuerst: \",\n", " sum_reaction_time_no_notifications_total_irregular_first/num_trials_no_notifications_total_irregular_first)\n", "print(\"Anzahl trials reguläre push notifications alle participants mit regulärem Block zuerst: \",\n", " num_trials_regular_notifications_total_regular_first)\n", "print(\"Anzahl trials reguläre push notifications alle participants mit irregulärem Block zuerst: \",\n", " num_trials_regular_notifications_total_irregular_first)\n", "print(\"durchschnittliche Reaktionszeit reguläre push notifications participants mit regulärem Block zuerst: \",\n", " sum_reaction_time_regular_notifications_total_regular_first/num_trials_regular_notifications_total_regular_first)\n", "print(\"durchschnittliche Reaktionszeit reguläre push notifications participants mit irregulärem Block zuerst: \",\n", " sum_reaction_time_regular_notifications_total_irregular_first/num_trials_regular_notifications_total_irregular_first)\n", "print(\"Anzahl trials irreguläre push notifications participants mit regulärem Block zuerst: \",\n", " num_trials_irregular_notifications_total_regular_first)\n", "print(\"Anzahl trials irreguläre push notifications participants mit irregulärem Block zuerst: \",\n", " num_trials_irregular_notifications_total_irregular_first)\n", "print(\"durchschnittliche Reaktionszeit irreguläre notification participants mit regulärem Block zuerst: \",\n", " sum_reaction_time_irregular_notifications_total_regular_first/num_trials_irregular_notifications_total_regular_first)\n", "print(\"durchschnittliche Reaktionszeit irreguläre notification participants mit irregulärem Block zuerst: \",\n", " sum_reaction_time_irregular_notifications_total_irregular_first/num_trials_irregular_notifications_total_irregular_first)\n", "\n", "print(\"Anzahl personen bei denen im dritten Block reguläre push notifications waren: \", num_participants_with_third_block_regular)\n", "\"\"\"\n", "\n", "# weight by block order\n", "\n", "weighted_reaction_time_no = (sum_reaction_time_no_notifications_total_regular_first/num_trials_no_notifications_total_regular_first + sum_reaction_time_no_notifications_total_irregular_first/num_trials_no_notifications_total_irregular_first) / 2\n", "# print(\"nach Blockreihenfolge gewichtete durchschnittliche Reaktionszeit ohne push notifications: \", weighted_reaction_time_no)\n", "weighted_reaction_time_reg = (sum_reaction_time_regular_notifications_total_regular_first/num_trials_regular_notifications_total_regular_first + sum_reaction_time_regular_notifications_total_irregular_first/num_trials_regular_notifications_total_irregular_first) / 2\n", "# print(\"nach Blockreihenfolge gewichtete durchschnittliche Reaktionszeit reguläre push notifications: \", weighted_reaction_time_reg)\n", "weighted_reaction_time_irreg = (sum_reaction_time_irregular_notifications_total_regular_first/num_trials_irregular_notifications_total_regular_first + sum_reaction_time_irregular_notifications_total_irregular_first/num_trials_irregular_notifications_total_irregular_first) / 2\n", "# print(\"nach Blockreihenfolge gewichtete durchschnittliche Reaktionszeit irreguläre push notifications: \", weighted_reaction_time_irreg) \n", "\n", "conditions = [\n", " \"no notifications\",\n", " \"regular\",\n", " \"irregular\"\n", "]\n", "\n", "proportions = [weighted_reaction_time_no, weighted_reaction_time_reg, weighted_reaction_time_irreg]\n", "\n", "colors = [\"gray\", \"steelblue\", \"orange\"]\n", "\n", "plt.figure()\n", "bars = plt.bar(conditions, means, yerr=stds, capsize=6, color=colors)\n", "\n", "plt.ylabel(\"average reaction time in ms\")\n", "plt.title(\"reaction time for each block condition\")\n", "plt.ylim(0, None)\n", "\n", "for bar, value in zip(bars, means):\n", " plt.text(bar.get_x() + bar.get_width()/2 + 0.1, bar.get_height() + 0.02,\n", " f\"{value:.0f}\", ha='center', va='bottom')\n", "\n", "plt.tight_layout()\n", "\n", "plt.savefig(\"reaction_time_block_condition.png\", dpi=300, bbox_inches=\"tight\")\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 7, "id": "80a83831-ccc6-4e23-8d36-faa520cd81e2", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# reaction time around notifications with values out of Descriptive Data analysis_correct.ipynb (not weighted by block order)\n", "\n", "means_new = [\n", " 420, # values out of Descriptive Data analysis_correct.ipynb notebook (not weighted by block order)\n", " 549,\n", " 508\n", "]\n", "stds_new = [ # standard deviation\n", " 387.25,\n", " 495.00,\n", " 459.96\n", "]\n", "\n", "conditions_new = [\n", " \"before notification\",\n", " \"notification trial\",\n", " \"after notification\"\n", "]\n", "\n", "colors_new = [\n", " \"#0b3c5d\", # dark blue\n", " \"#328cc1\", # middle blue\n", " \"#a7c7e7\" # light blue\n", "]\n", " \n", "plt.figure()\n", "bars = plt.bar(conditions_new, means_new, yerr=stds_new, capsize=6, color=colors_new)\n", "\n", "plt.ylabel(\"average reaction time in ms\")\n", "plt.title(\"reaction time around trials\")\n", "plt.ylim(0, None)\n", "\n", "for bar, value in zip(bars, means_new):\n", " plt.text(bar.get_x() + bar.get_width()/2 + 0.1, bar.get_height() + 0.02,\n", " f\"{value:.0f}\", ha='center', va='bottom')\n", "\n", "plt.tight_layout()\n", "\n", "plt.savefig(\"reaction_time_around_trials.png\", dpi=300, bbox_inches=\"tight\")\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 8, "id": "1f35bb0f-8bde-4344-8797-b5ec8cadad8c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Verteilung Accuracy – Keine Notifications\n", "4.0: 1 Personen\n", "5.0: 7 Personen\n", "6.0: 13 Personen\n", "7.0: 9 Personen\n", "8.0: 16 Personen\n", "9.0: 19 Personen\n", "10.0: 2 Personen\n", "\n", "Verteilung Accuracy – Reguläre Notifications\n", "3.0: 1 Personen\n", "4.0: 1 Personen\n", "5.0: 3 Personen\n", "6.0: 7 Personen\n", "7.0: 12 Personen\n", "8.0: 17 Personen\n", "9.0: 21 Personen\n", "10.0: 5 Personen\n", "\n", "Verteilung Accuracy – Irreguläre Notifications\n", "3.0: 1 Personen\n", "4.0: 3 Personen\n", "5.0: 3 Personen\n", "6.0: 9 Personen\n", "7.0: 8 Personen\n", "8.0: 22 Personen\n", "9.0: 18 Personen\n", "10.0: 3 Personen\n" ] } ], "source": [ "from collections import defaultdict\n", "\n", "# number of participants have which have which performance per condition\n", "performance_no = defaultdict(int)\n", "performance_reg = defaultdict(int)\n", "performance_irreg = defaultdict(int)\n", "\n", "for participant in real_data:\n", " trials = json.loads(participant['json_data'])\n", " \n", " correct_no = total_no = 0\n", " correct_reg = total_reg = 0\n", " correct_irreg = total_irreg = 0\n", "\n", " counter_real_trials = 0\n", " for trial in trials:\n", " if 'correct' not in trial:\n", " continue\n", " if counter_real_trials < treshold_second_block:\n", " condition = 'no'\n", " elif counter_real_trials < treshold_third_block:\n", " condition = trial['notif_block2_condition'] # 'regular' or 'irregular'\n", " else:\n", " condition = trial['notif_block3_condition']\n", " if condition == 'no':\n", " total_no += 1\n", " if trial['correct']:\n", " correct_no += 1\n", " elif condition == 'regular':\n", " total_reg += 1\n", " if trial['correct']:\n", " correct_reg += 1\n", " else: # irregular\n", " total_irreg += 1\n", " if trial['correct']:\n", " correct_irreg += 1\n", "\n", " counter_real_trials += 1\n", "\n", " if total_no > 0:\n", " percentage_correct_no = round(correct_no / total_no, 1)\n", " performance_no[percentage_correct_no * 10] += 1\n", " if total_reg > 0:\n", " percentage_correct_reg = round(correct_reg / total_reg, 1)\n", " performance_reg[percentage_correct_reg *10] += 1\n", " if total_irreg > 0:\n", " percentage_correct_irreg = round(correct_irreg / total_irreg, 1)\n", " performance_irreg[percentage_correct_irreg * 10] += 1\n", "\n", "print(\"\\nVerteilung Accuracy – Keine Notifications\")\n", "for acc in sorted(performance_no):\n", " print(f\"{acc}: {performance_no[acc]} Personen\")\n", "\n", "print(\"\\nVerteilung Accuracy – Reguläre Notifications\")\n", "for acc in sorted(performance_reg):\n", " print(f\"{acc}: {performance_reg[acc]} Personen\")\n", "\n", "print(\"\\nVerteilung Accuracy – Irreguläre Notifications\")\n", "for acc in sorted(performance_irreg):\n", " print(f\"{acc}: {performance_irreg[acc]} Personen\")" ] }, { "cell_type": "code", "execution_count": 9, "id": "4c2511e9-7a4e-4c73-bff7-e3d8a7de6b68", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import matplotlib.ticker as mticker\n", "\n", "# x-values from 0.0 to 1.0\n", "x_values = [i/10 for i in range(0, 11)]\n", "\n", "y_no = [performance_no.get(i, 0) for i in range(0, 11)]\n", "y_reg = [performance_reg.get(i, 0) for i in range(0, 11)]\n", "y_irreg = [performance_irreg.get(i, 0) for i in range(0, 11)]\n", "\n", "plt.figure()\n", "\n", "plt.plot(x_values, y_no, marker='o', color='gray',\n", " label='no notifications')\n", "\n", "plt.plot(x_values, y_reg, marker='o', color='steelblue',\n", " label='regular notifications')\n", "\n", "plt.plot(x_values, y_irreg, marker='o', color='orange',\n", " label='irregular notifications')\n", "\n", "plt.xlabel('proportion of correct trials')\n", "plt.ylabel('number of participants')\n", "plt.title('performance distribution per block condition')\n", "\n", "# Achsen festlegen\n", "plt.xlim(0, 1)\n", "max_y = max(max(y_no), max(y_reg), max(y_irreg))\n", "plt.ylim(0, max_y + 1)\n", "\n", "plt.xticks(x_values)\n", "plt.legend()\n", "plt.grid(True, alpha=0.3)\n", "\n", "plt.gca().yaxis.set_major_locator(mticker.MaxNLocator(integer=True))\n", "\n", "plt.savefig(\"performance_distribution.png\", dpi=300, bbox_inches=\"tight\")\n", "\n", "plt.show()\n", "\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "7325edb3-f2e5-40b6-8665-f351fbf3eaa8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Selected: ['Eidechse', 'Löwe', 'Papagei', 'Pinguin', 'Seestern']\n", "Notified: ['Seestern', 'Jaguar', 'Hamster', 'Schildkröte', 'Zebra', 'Eidechse', 'Krabbe', 'Frettchen', 'Koala', 'Giraffe', 'Eisbär', 'Elefant', 'Leopard', 'Eule', 'Gecko', 'Meerschweinchen', 'Hummer', 'Pinguin', 'Papagei', 'Tiger']\n", "Korrekt ausgewählt: {'Papagei', 'Pinguin', 'Eidechse', 'Seestern'}\n", "Anteil korrekt (bezogen auf notified): 0.2\n", "-----\n", "Selected: ['Ameise', 'Delfin', 'Elch', 'Esel', 'Flamingo', 'Hai', 'Kolibri', 'Kuh', 'Luchs', 'Möwe', 'Otter', 'Reh', 'Robbe', 'Seelöwe', 'Wal']\n", "Notified: ['Antilope', 'Libelle', 'Walross', 'Ameise', 'Stinktier', 'Schaf', 'Ziege', 'Otter', 'Kuh', 'Eichhörnchen', 'Kobra', 'Hai', 'Esel', 'Lachs', 'Delfin', 'Fledermaus', 'Möwe', 'Seelöwe', 'Elch', 'Flamingo']\n", "Korrekt ausgewählt: {'Seelöwe', 'Ameise', 'Elch', 'Möwe', 'Flamingo', 'Delfin', 'Esel', 'Otter', 'Kuh', 'Hai'}\n", "Anteil korrekt (bezogen auf notified): 0.5\n", "-----\n" ] } ], "source": [ "trials = json.loads(real_data[0]['json_data'])\n", "\n", "for trial in trials:\n", " if 'selected_animals' in trial and 'notified_animals' in trial:\n", " selected = trial['selected_animals']\n", " notified = trial['notified_animals']\n", " \n", " # calculate intersection\n", " correct_selected = set(selected) & set(notified)\n", " \n", " proportion_correct = len(correct_selected) / len(notified)\n", " \n", " print(\"Selected:\", selected)\n", " print(\"Notified:\", notified)\n", " print(\"correct selected:\", correct_selected)\n", " print(\"percentage correct:\", round(proportion_correct, 3))\n", " print(\"-----\")\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "21fa8c98-1391-4be5-a007-7d3516a427bf", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from scipy.stats import linregress\n", "\n", "all_prop_correct_trials = []\n", "all_prop_correct_animals = []\n", "all_ages = []\n", "young_trials = []\n", "young_animals = []\n", "other_trials = [] # for all older participants\n", "other_animals = []\n", "\n", "treshold_second_block = 96\n", "treshold_third_block = 96 * 2\n", "\n", "num_age_18_20 = 0\n", "num_age_21_24 = 0\n", "num_age_25_29 = 0\n", "num_age_30_39 = 0\n", "num_age_40_49 = 0\n", "num_age_50_plus = 0\n", "\n", "for participant in real_data: # iteration through all participants\n", " counter_real_trials = 0\n", " sum_prop_correct_animals = 0\n", " num_trials = 0\n", " num_correct_trials = 0\n", " trials = json.loads(participant['json_data']) # all trials of the participant\n", " age = trials[0]['demo_age_range']\n", " if (age == \"18-20\"):\n", " num_age_18_20 += 1\n", " elif (age == \"21-24\"):\n", " num_age_21_24 += 1\n", " elif (age == \"25-29\"):\n", " num_age_25_29 += 1\n", " elif (age == \"30-39\"):\n", " num_age_30_39 += 1\n", " elif (age == \"40-49\"):\n", " num_age_40_49 += 1\n", " else:\n", " num_age_50_plus += 1\n", " all_ages.append(age)\n", " for trial in trials: # iteration through all trials\n", " if ('correct' in trial):\n", " # add value on respective condition (1 if correkt, 0 if incorrect), verify previously whether correct_key exists\n", " # if correct_trial: add 1 to total number of trials\n", " num_trials += 1\n", " if (trial['correct']):\n", " num_correct_trials += 1\n", " counter_real_trials += 1\n", "\n", " if ('selected_animals' in trial and 'notified_animals' in trial):\n", " selected = trial['selected_animals']\n", " notified = trial['notified_animals']\n", " correct_selected = set(selected) & set(notified)\n", " proportion_correct = len(correct_selected) / len(notified)\n", " sum_prop_correct_animals += proportion_correct\n", " prop_correct_animals = sum_prop_correct_animals / 2\n", " prop_correct_trials = num_correct_trials/num_trials\n", " all_prop_correct_trials.append(prop_correct_trials)\n", " all_prop_correct_animals.append(prop_correct_animals)\n", "\n", " if age in ['18-20', '21-24']:\n", " young_trials.append(prop_correct_trials)\n", " young_animals.append(prop_correct_animals)\n", " else:\n", " other_trials.append(prop_correct_trials)\n", " other_animals.append(prop_correct_animals)\n", "\n", "# calculate regression line\n", "slope_all, intercept_all, r_all, p_all, std_err_all = linregress(all_prop_correct_trials, all_prop_correct_animals)\n", "slope_young, intercept_young, r_young, p_young, std_err_young = linregress(young_trials, young_animals)\n", "slope_other, intercept_other, r_other, p_other, std_err_other = linregress(other_trials, other_animals)\n", "\n", "plt.figure(figsize=(8,6))\n", "plt.scatter(all_prop_correct_trials, all_prop_correct_animals, color='red', label='all participants')\n", "plt.scatter(young_trials, young_animals, color='blue', label='age 18-24')\n", "plt.scatter(other_trials, other_animals, color='green', label='age 25+')\n", "\n", "# regression lines\n", "x_vals = np.linspace(0, 1, 100)\n", "plt.plot(x_vals, slope_all * x_vals + intercept_all, color='red', label=f'all fit, R²={r_all**2:.2f}')\n", "if slope_young is not None:\n", " plt.plot(x_vals, slope_young * x_vals + intercept_young, color='blue', linestyle='--', label=f'young fit, R²={r_young**2:.2f}')\n", "if slope_other is not None:\n", " plt.plot(x_vals, slope_other * x_vals + intercept_other, color='green', linestyle='--', label=f'other fit, R²={r_other**2:.2f}')\n", "\n", "plt.xlabel('proportion correct key-matching-trials')\n", "plt.ylabel('proportion correct animals')\n", "plt.title('regression of performances')\n", "plt.legend()\n", "\n", "plt.savefig(\"regression_animals_keymatching\", dpi=300, bbox_inches=\"tight\")\n", "\n", "\n", "plt.xlim(0, 1) # x-Achse von 0 bis 1\n", "plt.ylim(0, 1) # y-Achse von 0 bis 1\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 12, "id": "5d060799-cce0-4e7d-befe-b06b1ba4ab81", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Regular notifications:\n", "n = 67\n", "slope (b) = 0.7248553086329269\n", "r = 0.49204910519200395\n", "beta = 0.49204910519200395\n", "R² = 0.24211232192025178\n", "p = 2.347334956341251e-05\n", "\n", "Irregular notifications:\n", "n = 67\n", "slope (b) = 0.8234281605803386\n", "r = 0.5346075990043831\n", "beta = 0.5346075990043831\n", "R² = 0.2858052849132313\n", "p = 3.1613625963738975e-06\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# as above but divided by block condition instead of by age\n", "\n", "regular_trials = []\n", "regular_animals = []\n", "\n", "irregular_trials = []\n", "irregular_animals = []\n", "\n", "treshold_second_block = 96\n", "treshold_third_block = 96 * 2\n", "\n", "for participant in real_data:\n", " trials = json.loads(participant['json_data'])\n", "\n", " # key-matching performance separated by regular/irregular\n", " correct_regular = 0\n", " total_regular = 0\n", " correct_irregular = 0\n", " total_irregular = 0\n", "\n", " # animal recognition separated by regular/irregular\n", " animal_regular = None\n", " animal_irregular = None\n", "\n", " counter_real_trials = 0\n", " counter_animal_trials = 0\n", "\n", " for trial in trials:\n", " if 'correct' in trial:\n", " if counter_real_trials < treshold_second_block:\n", " # no-notification block ignorieren\n", " pass\n", " elif counter_real_trials < treshold_third_block:\n", " # zweiter Block\n", " condition = trial['notif_block2_condition']\n", " if condition == 'regular':\n", " total_regular += 1\n", " if trial['correct']:\n", " correct_regular += 1\n", " else:\n", " total_irregular += 1\n", " if trial['correct']:\n", " correct_irregular += 1\n", " else:\n", " # dritter Block\n", " condition = trial['notif_block3_condition']\n", " if condition == 'regular':\n", " total_regular += 1\n", " if trial['correct']:\n", " correct_regular += 1\n", " else:\n", " total_irregular += 1\n", " if trial['correct']:\n", " correct_irregular += 1\n", "\n", " counter_real_trials += 1\n", "\n", " if 'selected_animals' in trial and 'notified_animals' in trial:\n", " selected = trial['selected_animals']\n", " notified = trial['notified_animals']\n", " correct_selected = set(selected) & set(notified)\n", " proportion_correct = len(correct_selected) / len(notified)\n", "\n", " if counter_animal_trials == 0:\n", " condition = trial['notif_block2_condition']\n", " else:\n", " condition = trial['notif_block3_condition']\n", "\n", " if condition == 'regular':\n", " animal_regular = proportion_correct\n", " else:\n", " animal_irregular = proportion_correct\n", "\n", " counter_animal_trials += 1\n", "\n", " # save values for this participant\n", " if total_regular > 0 and animal_regular is not None:\n", " regular_trials.append(correct_regular / total_regular)\n", " regular_animals.append(animal_regular)\n", "\n", " if total_irregular > 0 and animal_irregular is not None:\n", " irregular_trials.append(correct_irregular / total_irregular)\n", " irregular_animals.append(animal_irregular)\n", "\n", "# calculate regression lines\n", "slope_reg, intercept_reg, r_reg, p_reg, std_err_reg = linregress(regular_trials, regular_animals)\n", "slope_irreg, intercept_irreg, r_irreg, p_irreg, std_err_irreg = linregress(irregular_trials, irregular_animals)\n", "\n", "print(\"\\nRegular notifications:\")\n", "print(f\"n = {len(regular_trials)}\")\n", "print(f\"slope (b) = {slope_reg}\")\n", "print(f\"r = {r_reg}\")\n", "print(f\"beta = {r_reg}\")\n", "print(f\"R² = {r_reg**2}\")\n", "print(f\"p = {p_reg}\")\n", "print(\"\\nIrregular notifications:\")\n", "print(f\"n = {len(irregular_trials)}\")\n", "print(f\"slope (b) = {slope_irreg}\")\n", "print(f\"r = {r_irreg}\")\n", "print(f\"beta = {r_irreg}\")\n", "print(f\"R² = {r_irreg**2}\")\n", "print(f\"p = {p_irreg}\")\n", "\n", "# plot\n", "plt.figure(figsize=(8, 6))\n", "\n", "plt.scatter(regular_trials, regular_animals, color='steelblue', label='regular notifications')\n", "plt.scatter(irregular_trials, irregular_animals, color='orange', label='irregular notifications')\n", "\n", "x_vals = np.linspace(0, 1, 100)\n", "plt.plot(\n", " x_vals,\n", " slope_reg * x_vals + intercept_reg,\n", " color='steelblue',\n", " linestyle='--',\n", ")\n", "plt.plot(\n", " x_vals,\n", " slope_irreg * x_vals + intercept_irreg,\n", " color='orange',\n", " linestyle='--',\n", ")\n", "\n", "plt.xlabel('proportion of correct symbol-key matching trials')\n", "plt.ylabel('proportion of correct animals')\n", "plt.title('correlation between symbol-key matching and animal recognition')\n", "plt.xlim(0, 1)\n", "plt.ylim(0, 1)\n", "plt.legend()\n", "\n", "plt.savefig(\"regression_animals_keymatching_regular_vs_irregular.png\", dpi=300, bbox_inches=\"tight\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 13, "id": "db31119b-fc94-44ec-9a4e-4e4447709164", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# plot ages\n", "\n", "conditions = [\n", " \"18 - 20\",\n", " \"21 - 24\",\n", " \"25 - 29\",\n", " \"30 - 39\",\n", " \"40 - 49\",\n", " \"50 +\"\n", "]\n", "\n", "proportions = [num_age_18_20, num_age_21_24, num_age_25_29, num_age_30_39, num_age_40_49, num_age_50_plus]\n", "\n", "plt.figure()\n", "bars = plt.bar(conditions, proportions)\n", "\n", "plt.ylabel(\"number of participants\")\n", "plt.title(\"participant's age\")\n", "\n", "for bar, value in zip(bars, proportions):\n", " plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.02,\n", " f\"{int(value)}\", ha='center', va='bottom')\n", "\n", "plt.tight_layout()\n", "\n", "plt.savefig(\"participants_age_distributions.png\", dpi=300, bbox_inches=\"tight\")\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "ea476108-f6b2-4d81-b02c-c1a93de799e2", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python [conda env:base] *", "language": "python", "name": "conda-base-py" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.13.9" } }, "nbformat": 4, "nbformat_minor": 5 }