{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# include controllers to the path\n", "import sys, os\n", "sys.path.append(os.getcwd())\n", "sys.path.append(os.path.join(os.getcwd(), 'controllers'))\n", "\n", "# include pipeline repo to compute performance\n", "sys.path.append(os.path.join(os.getcwd(), '..'))\n", "sys.path.append(os.path.join(os.getcwd(), '..', 'pipeline'))\n", "sys.path.append(os.path.join(os.getcwd(), '..', 'pipeline', 'postprocessing'))\n", "\n", "import cv2\n", "import threading\n", "import math\n", "import time\n", "import random\n", "import json\n", "import datetime\n", "import os, shutil\n", "import numpy as np\n", "import multiprocess as mp\n", "\n", "# controllers\n", "import nbimporter\n", "from controllers.situtils import FPSTimes\n", "from controllers.camera import WebcamStream\n", "from controllers.video import VideoWriter\n", "from controllers.position import PositionTrackerSingle, PositionTrackerDouble\n", "from controllers.sound import SoundController, ContinuousSoundStream\n", "from controllers.serial import MCSArduino, FakeArduino, SpeakerMotor, CableMotor\n", "from controllers.display import SITDisplay\n", "from controllers.island import IslandFactory\n", "\n", "from pipeline.postprocessing.pack import pack\n", "from pipeline.postprocessing.performance import calculate_performance, dump_performance_to_H5" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Load experiment settings\n", "\n", "For every experimental cofiguration you can copy the original 'settings.json' file, build your own specific experimental preset, save it in this folder as e.g. 'settings_elena.json' and load it here instead of 'settings.json'." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "cfg_filename = os.path.join('profiles', 'gokce_timeSIT_90_94.5.json')\n", "#'gokce_timeSIT_90_108.json')\n", "\n", "# cfg_filename = os.path.join('profiles', 'social_test_actual.json')\n", "# cfg_filename = os.path.join('profiles', 'andrey_hippoSIT_SL.json')" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "scrolled": false }, "outputs": [], "source": [ "with open(os.path.join('profiles', 'default.json')) as json_file:\n", " cfg = json.load(json_file)\n", "with open(cfg_filename) as json_file:\n", " cfg_local = json.load(json_file)\n", "\n", "for key in cfg.keys():\n", " cfg[key].update(cfg_local[key])\n", "cfg['experiment']['experiment_date'] = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')\n", "\n", "# print loaded settings\n", "#print(json.dumps(cfg, indent=4))" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# check if the sound interface is there\n", "import sounddevice as sd\n", "asio = [x for x in sd.query_devices() if x['name'].find('ASIO') > 0]\n", "#if len(asio) == 0:\n", "# raise SystemExit('The sound interface is not found. Please restart the computer')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Initialize session folder\n", "\n", "Run the upcoming cell, to create a session folder and to save the chosen experimetal parameters to a JSON-file (\"experiment_id_parameters.json\"). The session folder will be created here where this notebook is located." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# This session's protocols will be saved to this folder\n", "cfg_exp = cfg['experiment']\n", "experiment_id = \"%s_%s_%s\" % (cfg_exp['subject'], cfg_exp['experiment_type'], cfg_exp['experiment_date'])\n", "save_to = os.path.join('sessions', experiment_id)\n", " \n", "if not os.path.exists(save_to):\n", " os.makedirs(save_to)\n", "\n", "# update paths (assuming this paths are relative to this notebook)\n", "cfg['video']['file_path'] = os.path.join(save_to, cfg['video']['file_path'])\n", "cfg['position']['file_path'] = os.path.join(save_to, cfg['position']['file_path'])\n", "cfg['position']['contour_path'] = os.path.join(save_to, cfg['position']['contour_path'])\n", "cfg['experiment']['file_path'] = os.path.join(save_to, cfg['experiment']['file_path'])\n", "cfg['experiment']['islands_path'] = os.path.join(save_to, 'islands.csv')\n", "cfg['sound']['file_path'] = os.path.join(save_to, cfg['sound']['file_path'])\n", "cfg['position']['background_light'] = os.path.join('assets', cfg['position']['background_light'])\n", "cfg['position']['background_dark'] = os.path.join('assets', cfg['position']['background_dark'])\n", "if 'continuous' in cfg['sound']:\n", " cfg['sound']['continuous']['wav_file'] = os.path.join('assets', cfg['sound']['continuous']['wav_file'])\n", " \n", "# Saves all parameters to a JSON file with the user-defined \"Experiment ID\" as filename\n", "with open(os.path.join(save_to, experiment_id + '.json'), 'w') as f:\n", " json.dump(cfg, f, indent=4)\n", " \n", "with open(cfg['experiment']['file_path'], 'w') as f:\n", " # state: 0 - trial start, 1 - trial success, 2 - trial fail\n", " f.write('time, target_x, target_y, target_r, trial, state\\n')\n", "\n", "with open(cfg['experiment']['islands_path'], 'w') as f:\n", " f.write('tgt_x, tgt_y, tgt_r, d1_x, d1_y, d1_r, d2_x, d2_y, d2_r, d3_x, d3_y, d3_r\\n')" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def timeout(t_start):\n", " return time.time() - t_start > cfg_exp['session_duration'] if t_start is not None else False" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def log_event(*args): # log start / end of a trial\n", " with open(cfg_exp['file_path'], 'a') as f:\n", " f.write(\",\".join([str(x) for x in args]) + \"\\n\")" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def log_islands(islands): # log position of the islands\n", " sorted_islands = sorted(islands, key=lambda x: x.sound_id, reverse=False)\n", " args = [(i.x, i.y, i.r) for i in sorted_islands]\n", " to_dump = [x for xs in args for x in xs]\n", " \n", " with open(cfg_exp['islands_path'], 'a') as f: \n", " f.write(\",\".join([str(round(x, 4)) for x in to_dump]) + \"\\n\")" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def switch_light(pt, board):\n", " pt.switch_background()\n", " board.switch_light()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Start the experiment\n", "\n", "This cell contains code for animal tracking. We hope that the comments provided in the code suffice to understand the individual steps and to adjust them to your own setup and needs, if necessary.\n", "\n", "- press 's' to start recording\n", "- press 's' again to stop recording\n", "- press 'q' to quit\n", "\n", "The experiment will stop automatically if the pre-defined session duration is reached." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Webcam stream 1024.0:768.0 at 30.00 FPS started\n", "Position tracker stopped\n", "Video writer stopped\n", "Camera released\n" ] } ], "source": [ "# actual sound selector: -1 - noise, 0 - silence, 1 - foraging, 2 - target, 3 - distractor\n", "sound = mp.Value('i', 1)\n", "if 'noise_when_idle' in cfg_exp and cfg_exp['noise_when_idle']:\n", " sound.value = -1\n", "\n", "# experiment status: 1 - idle, 2 - running (recording, logging), 0 - stopped\n", "status = mp.Value('i', 1)\n", "\n", "# init the sync with the acquisition system and feeder via Arduino\n", "if cfg['experiment']['MCSArduinoPort'] == 'fake':\n", " board = FakeArduino()\n", "else:\n", " board = MCSArduino(cfg['experiment']['MCSArduinoPort'])\n", "\n", "# init speaker motor control\n", "if 'motors_port' in cfg['experiment'] and cfg['experiment']['enable_motors']:\n", " motor_board = SpeakerMotor(cfg['experiment']['motors_port'])\n", " \n", "# init ephys cable rotation motor\n", "if 'cable_motor_port' in cfg['experiment']:\n", " cable_board = CableMotor(cfg['experiment']['cable_motor_port'])\n", "\n", "# init continuous sound, if required\n", "if 'continuous' in cfg['sound']:\n", " cst = ContinuousSoundStream(cfg['sound']['continuous'])\n", " cst.start()\n", " \n", "# start the camera stream\n", "vs = WebcamStream(cfg['camera'])\n", "vs.start()\n", "\n", "# init video recorder\n", "vw = VideoWriter(status, vs, cfg['video'])\n", "vw.start()\n", "\n", "# start position tracking\n", "pt = PositionTrackerSingle(status, vs, cfg['position']) if cfg['position']['single_agent'] else PositionTrackerDouble(status, vs, cfg['position'])\n", "pt.start()\n", "# print(pt.mask.shape)\n", "# init frame renderer\n", "dc = SITDisplay(pt, cfg['video'])\n", "\n", "# playing sound in a separate process for performance\n", "sc = mp.Process(target=SoundController.run, args=(sound, status, cfg['sound']))\n", "sc.start()\n", "\n", "cfg_pos = cfg['position']\n", "isl_factory = IslandFactory(cfg_pos['floor_r_in_meters'], cfg_pos['angle_compensation'], cfg['experiment'])\n", "\n", "timers = []\n", "fps = FPSTimes()\n", "names = ['camera', 'video', 'position', 'main']\n", "distr_count = cfg['experiment']['distractor_islands']\n", "trial = 0\n", "rewards = 0\n", "t_start = None\n", "target_since = None\n", "distractor_since = None\n", "punishment_since = None\n", "trial_start = time.time()\n", "phase = 0 # 0 - idle, 1 - foraging, 2 - inter-trial interval\n", "cfg_exp = cfg['experiment']\n", "cfg_pos = cfg['position']\n", "islands = []\n", "iti_distance = 0.0\n", "last_x, last_y = None, None\n", "\n", "# initial position of the island, if set\n", "#phi_initial = np.random.rand() * 2 * np.pi if cfg_exp['target_angle'] == 'random' else np.deg2rad(int(cfg_exp['target_angle']))\n", "#rho = pt.cfg['floor_radius'] * pt.pixel_size - cfg_exp['target_radius'] # constant, in meters\n", "\n", "\n", "# inaudible island trial profiles\n", "max_trials = 200\n", "p0 = np.array([0 for x in range(max_trials)]) # never\n", "p1 = np.array([0 if (x+1) % 4 > 0 else 1 for x in range(max_trials)]) # every 4-th trial\n", "p2 = np.array([0 if (x+1) % 2 > 0 else 1 for x in range(max_trials)]) # every 2-nd trial\n", "p3 = np.array([1 if x % 4 > 0 else 0 for x in range(max_trials)]) # always except every 4-th trial\n", "unaudible_trials = np.vstack([p0, p1, p2, p3])\n", "\n", "## TODO refactor a) trial init, b) trial failure and c) trial success as separate functions - read about state mgmt\n", "\n", "try:\n", " while trial <= cfg_exp['trial_number'] and not timeout(t_start):\n", " \n", " # ---------- rendering logic -----------\n", " frame = vs.read()\n", " if frame is None:\n", " time.sleep(0.1)\n", " continue # wait for the stream\n", " \n", " c_time = time.time()\n", " fps.count()\n", " angles, text_infos = [], []\n", " \n", " if not cfg_exp['target_angle'] == 'random':\n", " phi = isl_factory.phi_initial\n", " angles = [pt.correct_angle(phi), pt.correct_angle(phi) + np.deg2rad(cfg_exp['phi_max'])]\n", " \n", " for i, ctrl in enumerate([vs, vw, pt, fps]): # FPS indicators\n", " text_infos.append('%s: %.2f FPS' % (names[i], ctrl.get_avg_fps()))\n", " \n", " if len(islands) > 0: # target island X, Y\n", " target = [i for i in islands if not i.is_distractor][0]\n", " text_infos.append('Target: %.3f %.3f' % (target.x, target.y))\n", "# print(frame.shape) \n", " text_infos.append('Time: %.2f' % float(c_time - t_start) if t_start is not None else 'Time: Idle') # stopwatch\n", " text_infos.append('Trial: %.2f' % float(cfg_exp['trial_duration'] - (c_time - trial_start)) if phase == 1 else 'Trial: not started')\n", " text_infos.append('Trial: %s' % trial)\n", " text_infos.append('Rewards: %s' % rewards) # rewards\n", " text_infos.append('In target: %.2f' % float(c_time - target_since) if target_since is not None else 'In target: --')\n", " text_infos.append('ITI distance: %.2f' % iti_distance if iti_distance > 0 else 'ITI distance: --')\n", "\n", " frame, frame_to_save = dc.render(frame, status, islands=islands, angles=angles, text_infos=text_infos)\n", " \n", " # assign the frame back to the video stream for other controllers\n", " vs.frame_with_infos = frame_to_save\n", " \n", " cv2.imshow('Press (s)-to start/stop, (q)-to end', frame)\n", "\n", " # -------- experiment logic ---------------\n", " \n", " # animals is either foraging (phase == 1) or in the inter-trial-interval (phase == 2)\n", " if phase == 1: # foraging\n", " if pt.positions_in_m is not None and len(islands) > 0:\n", " # check if animal in the island and for how long\n", " tgt = [i for i in islands if not i.is_distractor][0]\n", " distractors = [i for i in islands if i.is_distractor]\n", " \n", " if pt.is_inside(tgt.x, tgt.y, cfg_exp['target_radius']):\n", " if target_since is None: # just entered target\n", " target_since = c_time\n", " if unaudible_trials[cfg_exp['unaudible_profile']][trial - 1] == 0:\n", " sound.value = 2\n", "\n", " elif c_time - target_since > cfg_exp['target_duration']: # successful trial\n", " log_event(c_time, round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4), trial, 1) # log trial success\n", " board.feed()\n", " \n", " # init inter-trial interval and new trial\n", " trial_start = c_time + cfg_exp['iti_duration'] + 5 * np.random.rand() # random b/w 20-25 sec\n", " sound.value = 0 # silence\n", " islands = []\n", " phase = 2\n", " rewards += 1\n", " target_since = None\n", " \n", " elif c_time - trial_start > cfg_exp['trial_duration']: # trial failed and animal is not in the target\n", " ## TODO refactor this + trial fail below into a function\n", " log_event(c_time, round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4), trial, 2) # log trial failed because of time\n", " trial_start = c_time + cfg_exp['iti_duration'] + 5 * np.random.rand() # random b/w 10-15 sec\n", " sound.value = -1 # punishment\n", " punishment_since = c_time\n", " islands = []\n", " phase = 2\n", " distractor_since = None\n", " target_since = None # take care of the case in which animal was in target at trial end but exited before target_duration\n", " \n", " else:\n", " target_since = None\n", " in_distractor = False\n", " \n", " for isl in distractors: # maybe animal is in one of the distractors\n", " if pt.is_inside(isl.x, isl.y, cfg_exp['target_radius']):\n", " if distractor_since is None: # just entered distractor\n", " distractor_since = c_time\n", " \n", " sound.value = isl.sound_id\n", " in_distractor = True\n", " \n", " if c_time - distractor_since > cfg_exp['target_duration'] and cfg_exp['distractor_fail']:\n", " # fail trial because in distractor\n", " log_event(c_time, round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4), trial, 2) # log trial failed\n", " trial_start = c_time + cfg_exp['iti_duration'] + 5 * np.random.rand() # random b/w 10-15 sec\n", " sound.value = -1 # punishment\n", " punishment_since = c_time\n", " islands = []\n", " phase = 2\n", " distractor_since = None\n", " else:\n", " distractor_since = None\n", " \n", " if not in_distractor: # outside of the islands\n", " sound.value = 1\n", " \n", " elif phase == 2: # inter-trial-interval\n", " # count distance between trials\n", " if last_x is None:\n", " last_x, last_y = pt.positions_in_m[0]\n", " else:\n", " x, y = pt.positions_in_m[0]\n", " iti_distance += np.sqrt((x - last_x)**2 + (y - last_y)**2)\n", " last_x, last_y = x, y\n", " \n", " # reset punishment sound\n", " if punishment_since is not None and c_time - punishment_since > cfg_exp['punishment_duration']:\n", " sound.value = 0\n", " punishment_since = None\n", "\n", " if c_time > trial_start and iti_distance > cfg_exp['iti_distance'] and \\\n", " isl_factory.last_tgt_x is not None and not pt.is_inside(isl_factory.last_tgt_x, isl_factory.last_tgt_y, cfg_exp['target_radius']):\n", " ## TODO refactor this + trial init below into a function\n", " # init_new_trial\n", " islands = isl_factory.generate_islands(c_time - t_start)\n", " log_islands(islands) # log island(s) positions\n", " sound.value = 1\n", " phase = 1\n", " trial += 1\n", " \n", " # reset ITI distance and trial_start\n", " iti_distance = 0\n", " trial_start = c_time\n", " \n", " # log trial start\n", " tgt = [i for i in islands if not i.is_distractor][0]\n", " log_event(c_time, round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4), trial, 0)\n", " \n", " # -------- key press events ---------------\n", " \n", " k = cv2.waitKey(33)\n", " \n", " # light on/off\n", " if k == ord('l'):\n", " switch_light(pt, board)\n", " \n", " # motors\n", " if k == ord('d'):\n", " if cfg['experiment']['enable_motors']:\n", " motor_board.switch_diodes()\n", " \n", " # disable motor control for safety\n", " #if k == ord('t'):\n", " # tm = threading.Timer(20, motor_board.rotate, args=(False, 90, 30))\n", " # tm.start()\n", " # #motor_board.rotate(False, 90, 30)\n", " #if k == ord('r'):\n", " # tm = threading.Timer(20, motor_board.rotate, args=(True, 90, 30))\n", " # tm.start()\n", " \n", " # ephys cable on top\n", " if k == ord('i') and 'cable_motor_port' in cfg['experiment']:\n", " tf = threading.Timer(0, cable_board.turn_CCW, args=[])\n", " tf.start()\n", " if k == ord('o') and 'cable_motor_port' in cfg['experiment']:\n", " tf = threading.Timer(0, cable_board.turn_CW, args=[])\n", " tf.start()\n", " \n", " # feeding\n", " if k == ord('f'):\n", " tf = threading.Timer(0, board.feed, args=[])\n", " tf.start()\n", "\n", " if k == ord('c'):\n", " f_name = cfg_pos['background_light'] if pt.is_light else cfg_pos['background_dark']\n", " cv2.imwrite(f_name, dc.masked_frame)\n", " tf = threading.Timer(0.2, pt.reload_background, args=[])\n", " tf.start() \n", "\n", " # quit the session\n", " if k == ord('q'):\n", " break\n", "\n", " # start the experiment\n", " if k == ord('s'):\n", " board.start_or_stop() # start/stop data acquisition\n", " c_time = time.time() # more accurate time\n", " \n", " if cfg['experiment']['enable_motors']:\n", " if not motor_board.diodes_on:\n", " motor_board.switch_diodes()\n", "\n", " if status.value == 1: # start the session\n", " if t_start is None:\n", " t_start = c_time\n", " trial_start = c_time\n", " status.value = 2\n", " \n", " # init_new_trial\n", " islands = isl_factory.generate_islands(c_time - t_start)\n", " log_islands(islands) # log island(s) positions\n", " sound.value = 1\n", " phase = 1\n", " trial += 1\n", "\n", " # log trial start\n", " tgt = [i for i in islands if not i.is_distractor][0]\n", " log_event(c_time, round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4), trial, 0)\n", " \n", " # init light events\n", " timers = []\n", " for event_t in cfg_exp['light_events']:\n", " timers.append(threading.Timer(event_t, switch_light, args=(pt, board)))\n", " \n", " if cfg['experiment']['enable_motors']:\n", " if not cfg['experiment']['phi_max'] == 0:\n", " direction = False if cfg['experiment']['phi_max'] > 0 else True\n", " t0, t1 = cfg['experiment']['timepoints'][0], cfg['experiment']['timepoints'][1]\n", " timers.append(threading.Timer(t0, motor_board.rotate, args=(direction, abs(cfg['experiment']['phi_max']), t1-t0)))\n", " t0, t1 = cfg['experiment']['timepoints'][2], cfg['experiment']['timepoints'][3]\n", " timers.append(threading.Timer(t0, motor_board.rotate, args=(not direction, abs(cfg['experiment']['phi_max']), t1-t0)))\n", " \n", " for t in timers:\n", " t.start()\n", " \n", " elif status.value == 2: # pause the session\n", " if len(islands) > 0:\n", " tgt = [i for i in islands if not i.is_distractor][0]\n", " x, y, r = round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4)\n", " else:\n", " x, y, r = 0, 0, 0\n", " log_event(c_time, x, y, r, trial, -1) # log experiment break\n", " \n", " if 'noise_when_idle' in cfg_exp and cfg_exp['noise_when_idle']:\n", " sound.value = -1\n", " status.value = 1\n", " phase = 0\n", " islands = []\n", " for t in timers:\n", " t.cancel()\n", " \n", " if k == ord('a'):\n", " sound.value = -1 if sound.value >= 0 else 0\n", " switch_light(pt, board) # turn lights off \n", "\n", "finally:\n", " if status.value == 2: # stop data acquisition, in case exited via timeout\n", " board.start_or_stop()\n", " if len(islands) > 0:\n", " tgt = [i for i in islands if not i.is_distractor][0]\n", " x, y, r = round(tgt.x, 4), round(tgt.y, 4), round(tgt.r, 4)\n", " else: \n", " x, y, r = 0, 0, 0\n", " log_event(c_time, x, y, r, trial, -1) # log experiment end\n", " \n", " status.value = 0\n", " time.sleep(0.01)\n", " for t in timers:\n", " t.cancel()\n", " \n", " if board.is_light_off:\n", " board.switch_light() # turn light back on\n", " time.sleep(0.1)\n", " board.exit()\n", " \n", " if cfg['experiment']['enable_motors']:\n", " if motor_board.diodes_on:\n", " motor_board.switch_diodes()\n", " motor_board.exit()\n", " if 'cable_motor_port' in cfg['experiment']:\n", " cable_board.exit()\n", " \n", " cv2.destroyAllWindows()\n", " sc.join()\n", " for ctrl in [pt, vw, vs]:\n", " ctrl.stop()\n", "\n", " if 'continuous' in cfg['sound']:\n", " time.sleep(cfg['sound']['continuous']['end_sleep'])\n", " cst.stop()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Merge data in HDF5 file" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "session_path = save_to\n", "#session_path = os.path.join('sessions', '2021-07-30_09-24-14') # some particular session\n", "#session_path = 'Y:\\\\Michael\\\\FreeBehaving\\\\SIT_sessions\\\\50_aSIT_2021-10-25_10-32-19'" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "if not trial > 0:\n", " raise SystemExit('Nothing recorded. No sense to continue.')\n", "\n", "# do pack data to HDF5\n", "h5name = pack(session_path)\n", "trial = 0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plot sessions stats" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import h5py\n", "import numpy as np\n", "from scipy import signal" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "arena_r = 0.4 # in meters\n", "\n", "with h5py.File(h5name, 'r') as f:\n", " tl = np.array(f['processed']['timeline'])\n", " trial_idxs = np.array(f['processed']['trial_idxs'])" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "scrolled": false }, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 1.0, 'Speed')" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig = plt.figure(figsize=(12, 12))\n", "\n", "# trajectory and islands\n", "ax = fig.add_subplot(221)\n", "ax.scatter(tl[:, 1], tl[:, 2], s=1, alpha=0.1) # positions\n", "scat = ax.scatter(trial_idxs[:, 2], trial_idxs[:, 3], s=1000, facecolors='none', edgecolors='r') # islands, radius approx.\n", "ax.add_patch(plt.Circle((0, 0), arena_r, color='r', fill=False))\n", "ax.set_aspect('equal')\n", "ax.set_xlabel('X, m', fontsize=14)\n", "ax.set_ylabel('Y, m', fontsize=14)\n", "ax.set_title('Running', fontsize=14)\n", "ax.grid()\n", "\n", "# occupancy\n", "sigma = 0.1\n", "lin_profile = np.linspace(-15, 15, 20)\n", "bump = np.exp(-sigma * lin_profile**2)\n", "bump /= np.trapz(bump) # normalize to 1\n", "kernel = bump[:, np.newaxis] * bump[np.newaxis, :]\n", "occupancy_map, _, _ = np.histogram2d(tl[:, 1], tl[:, 2], bins=[40, 40], range=np.array([[-0.5, 0.5], [-0.5, 0.5]]))\n", "occupancy_map = signal.convolve2d(occupancy_map, kernel, mode='same')\n", "\n", "ax = fig.add_subplot(222)\n", "ax.imshow(occupancy_map.T, origin='lower', extent=(-0.5, 0.5, -0.5, 0.5), cmap='Blues')\n", "ax.add_patch(plt.Circle((0, 0), arena_r, color='r', fill=False))\n", "ax.set_xlabel('X, m', fontsize=14)\n", "ax.set_title('Occupancy', fontsize=14)\n", "ax.grid()\n", "\n", "# trials\n", "durations = tl[trial_idxs[:, 1].astype(int)][:, 0] - tl[trial_idxs[:, 0].astype(int)][:, 0]\n", "colors = ['red' if x == 1 else 'grey' for x in trial_idxs[:, 5]]\n", "\n", "ax = fig.add_subplot(223)\n", "ax.barh(np.arange(len(trial_idxs)), durations, color=colors, align='center')\n", "ax.set_xlabel('Time, s', fontsize=14)\n", "ax.set_ylabel('Trial, #', fontsize=14)\n", "ax.set_title('Trials', fontsize=14)\n", "\n", "# speed\n", "ax = fig.add_subplot(224)\n", "ax.hist(tl[:, 3], bins=50, ec='black')\n", "ax.set_xlabel('Speed, m/s', fontsize=14)\n", "ax.set_title('Speed', fontsize=14)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Performance" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "h5name = os.path.join(session_path, experiment_id + '.h5')\n", "jsname = os.path.join(session_path, experiment_id + '.json')\n", "\n", "# loading position and trial data\n", "with h5py.File(h5name, 'r') as f:\n", " tl = np.array(f['processed']['timeline']) # time, X, Y, speed\n", " trial_idxs = np.array(f['processed']['trial_idxs']) # idx start, idx end, X, Y, R, trial result (idx to tl)\n", "\n", "# loading session configuration\n", "with open(jsname, 'r') as f:\n", " cfg = json.load(f)\n", "\n", "timepoints = cfg['experiment']['timepoints']\n", "s_duration = cfg['experiment']['session_duration']\n", "\n", "periods = [[0, s_duration], [0, timepoints[0]], [timepoints[1], timepoints[2]], [timepoints[3], s_duration]]\n", "\n", "# separate ALL, L, D, L'\n", "ds_names = ['performance_ALL', 'performance_L', 'performance_D', 'performance_Lp']\n", "ds_names = ['performance_ALL'] # only light\n", "\n", "for i, ds_name in enumerate(ds_names):\n", " t_start, t_end = periods[i]\n", " trial_starts = tl[trial_idxs[:, 0].astype(np.int32)][:, 0]\n", " trial_ends = tl[trial_idxs[:, 1].astype(np.int32)][:, 0]\n", " tr_idxs = trial_idxs[(trial_starts >= t_start) & (trial_ends <= t_end)]\n", "\n", " dataset = calculate_performance(tl, tr_idxs, cfg)\n", " dump_performance_to_H5(h5name, ds_name, dataset)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig = plt.figure(figsize=(4, 4))\n", "\n", "with h5py.File(h5name, 'r') as f:\n", " perf = np.array(f['analysis']['performance_ALL'])\n", " x = perf[:, 6]\n", "\n", "ax = fig.add_subplot(111)\n", "\n", "ax.plot(x, perf[:, 0]) # performance\n", "ax.plot(x, perf[:, 3]) # chance\n", "ax.fill_between(x, perf[:, 0] + perf[:, 1], perf[:, 0] + perf[:, 2], alpha=0.4)\n", "ax.fill_between(x, perf[:, 3] + perf[:, 4], perf[:, 3] + perf[:, 5], alpha=0.4)\n", "ax.set_ylim(0, 110)\n", "ax.set_xlim(0, 65)\n", "ax.grid()\n", "ax.set_title(experiment_id[-19:], fontsize=14)\n", "ax.set_xlabel('Time, s', fontsize=14)\n", "\n", "if i == 0:\n", " ax.set_ylabel('Successful trials, %', fontsize=14)\n", " \n", "fig.tight_layout()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "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.8.8" } }, "nbformat": 4, "nbformat_minor": 2 }