1_Performance_forPPSeq.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# import and functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "Fs = 30000.0\n",
    "\n",
    "def parts(list_, indices):\n",
    "    indices = [0]+indices+[len(list_)]\n",
    "    return [list_[v:indices[k+1]] for k, v in enumerate(indices[:-1])]\n",
    "\n",
    "def RemoveSlowSequences(split,split2):\n",
    "    timefiltered_split = []\n",
    "    for i,item in enumerate(split2):\n",
    "        if item[0] == 1:\n",
    "            timefiltered_split = timefiltered_split + [split[i]]\n",
    "\n",
    "    return(timefiltered_split)\n",
    "\n",
    "def aligntofirstpokeandremovesingletransits(timesplitseqs,timesplitlatencies):\n",
    "    \n",
    "    newseqs = []\n",
    "    newlatencies = []\n",
    "    # align to first poke:\n",
    "    for index_1,fragments in enumerate(timesplitseqs):\n",
    "        current_newseqs = []\n",
    "        current_newlatencies = []\n",
    "        count = -1\n",
    "        seqs = False\n",
    "        for index_2,sequence in enumerate(fragments):\n",
    "            for index_3,transit in enumerate(sequence):\n",
    "                if not str(transit)[0] == str(transit)[1]: # remove repeat pokes\n",
    "                    if str(transit)[0] == '2':\n",
    "                        seqs = True\n",
    "                        current_newseqs = current_newseqs + [[]]\n",
    "                        current_newlatencies = current_newlatencies + [[]]\n",
    "                        count = count + 1\n",
    "                        current_newseqs[count] = current_newseqs[count] + [transit]\n",
    "                        current_newlatencies[count] = current_newlatencies[count] + [timesplitlatencies[index_1][index_2][index_3]]\n",
    "                    elif seqs == True:\n",
    "                        current_newseqs[count] = current_newseqs[count] + [transit]   \n",
    "                        current_newlatencies[count] = current_newlatencies[count] + [timesplitlatencies[index_1][index_2][index_3]]\n",
    "            seqs = False\n",
    " \n",
    "        newseqs = newseqs + [current_newseqs]\n",
    "        newlatencies = newlatencies + [current_newlatencies]\n",
    "    return(newseqs,newlatencies)\n",
    "\n",
    "def generate_processed_transitiontimesdataframe(processed_seqs,processed_latencies,counter):\n",
    "\n",
    "    count = counter\n",
    "    transits= []\n",
    "    trial_number= []\n",
    "    for fragment in processed_seqs:\n",
    "        count = count + 1\n",
    "        if len(fragment) > 0:\n",
    "            for sequence in fragment:\n",
    "                for transit in sequence:\n",
    "                    trial_number = trial_number + [count]\n",
    "                    transits = transits + [transit]\n",
    "        else: ### deals with cases where there are no good transitions in a trial \n",
    "            transits = transits + ['nan']\n",
    "            trial_number = trial_number + [count]\n",
    "\n",
    "    times = []\n",
    "    for fragment in processed_latencies:\n",
    "        if len(fragment) > 0:\n",
    "            for sequence in fragment:\n",
    "                for time in sequence:\n",
    "                    times = times + [time]\n",
    "        else:\n",
    "            times = times + ['nan']\n",
    "\n",
    "    Processesed_Transition_Latencies = pd.DataFrame({'Trial': trial_number, 'Transitions' : transits,'Latencies' : times})\n",
    "\n",
    "    return(Processesed_Transition_Latencies,count)\n",
    "\n",
    "def sequence_contains_sequence(haystack_seq, needle_seq):\n",
    "    for i in range(0, len(haystack_seq) - len(needle_seq) + 1):\n",
    "        if needle_seq == haystack_seq[i:i+len(needle_seq)]:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "def convolve_movmean(y,N):\n",
    "    y_padded = np.pad(y, (N//2, N-1-N//2), mode='edge')\n",
    "    y_smooth = np.convolve(y_padded, np.ones((N,))/N, mode='valid') \n",
    "    return y_smooth\n",
    "\n",
    "def SaveFig(file_name,figure_dir):\n",
    "    if not os.path.isdir(figure_dir):\n",
    "        os.makedirs(figure_dir)\n",
    "    plt.savefig(figure_dir + file_name, bbox_inches='tight')\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# set paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Paths\n",
    "\n",
    "\n",
    "animal = 'seq006_implant1'\n",
    "\n",
    "path = r'Z:\\projects\\sequence_squad\\revision_data\\organised_data\\animals\\\\' + animal + '\\\\'\n",
    "\n",
    "# Set as True to create baseline files that will need to be edited manually later to select timeframe:\n",
    "create_intervales_txt = True\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# main data loop "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This loops across the data structure for the given animal and uses the behavuour synchronisation file which relates preprocessed bpod data (poke times) to ephys timestamps. The output is a performance score (how well the mouse did the sequence across trials) in ephys time coordinates. This allows us to later chose an ephys time period when the animal was perfroming the task well/consitently. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "recording10_27-11-2024\n",
      "recording11_28-11-2024\n",
      "recording1_15-11-2024\n",
      "recording2_16-11-2024\n",
      "no data for this recording\n",
      "recording3_18-11-2024\n",
      "recording4_19-11-2024\n",
      "recording5_20-11-2024\n",
      "recording6_21-11-2024\n",
      "recording7_22-11-2024\n",
      "recording8_25-11-2024\n",
      "recording9_26-11-2024\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for recording in os.listdir(path):\n",
    "    if not 'Store' in recording: # ignore ds store thing\n",
    "        if 'recording' in recording:\n",
    "            print(recording)\n",
    "            current_path = os.path.join(path,recording,'behav_sync') + '\\\\'\n",
    "            for file in os.listdir(current_path):\n",
    "                if 'task' in file:\n",
    "                    current_path =  os.path.join(current_path,file) + '\\\\' \n",
    "            try:         \n",
    "                sync_data =  pd.read_csv(current_path + 'Transition_data_sync.csv')\n",
    "                sync_data2 =  pd.read_csv(current_path + 'Behav_Ephys_Camera_Sync.csv')\n",
    "\n",
    "                output_path = os.path.join(path,recording,'post_process_ppseq') + '\\\\' \n",
    "\n",
    "                # these are important for concainating trials later on!\n",
    "                counter1 = -1\n",
    "                counter2 = -1\n",
    "\n",
    "                #split data by trials \n",
    "                trial_split_data = dict(tuple(sync_data.groupby('Trial_id')))\n",
    "\n",
    "                # pull out transitions and timefilter data for each trial:\n",
    "                transitions = []\n",
    "                Tfilters= [[],[]]\n",
    "                latencies = [[],[]]\n",
    "                for i in trial_split_data:\n",
    "                    transitions = transitions + [list(trial_split_data[i].loc[:,'Transition_type'])]\n",
    "                    Tfilters[0] = Tfilters[0] + [list(trial_split_data[i].loc[:,'2s_Time_Filter_out_in'])]\n",
    "                    latencies[0] = latencies[0] +[list(trial_split_data[i].loc[:,'out_in_Latency'])]   \n",
    "                    # in in\n",
    "                    Tfilters[1] = Tfilters[1] + [list(trial_split_data[i].loc[:,'2s_Time_Filter_in_in'])]\n",
    "                    latencies[1] = latencies[1] +[list(trial_split_data[i].loc[:,'in_in_Latency'])]    \n",
    "\n",
    "                # for each trial,remove transntions that were too long and split into reaminign time relevant fragments - but for both latency types, hence the loop\n",
    "                timesplitseqs = [[],[]]\n",
    "                for i in range(2):\n",
    "                    Tfilt = Tfilters[i] # use out to in pokes first then in in .\n",
    "                    for trial_index,time_filter in enumerate(Tfilt):\n",
    "                        start_end_inds = list(np.where(np.array(time_filter)[:-1] != np.array(time_filter)[1:])[0])\n",
    "                        split = parts(transitions[trial_index],list(np.array(start_end_inds)+1))\n",
    "                        split2 = parts(Tfilt[trial_index],list(np.array(start_end_inds)+1))\n",
    "                        TfiltSplit = RemoveSlowSequences(split,split2)\n",
    "                        del split[::2] # remove every 2nd item eg. all the transitions that were timefilter = 0 so were too long. \n",
    "                        timesplitseqs[i] = timesplitseqs[i] + [TfiltSplit]\n",
    "\n",
    "                ## do the exact same for latency - but for both latency types, hence the loop:\n",
    "                timesplitlatencies = [[],[]]\n",
    "                for i in range(2):\n",
    "                    Tfilt = Tfilters[i] \n",
    "                    latency = latencies[i]\n",
    "                    for trial_index,time_filter in enumerate(Tfilt):\n",
    "                        start_end_inds = list(np.where(np.array(time_filter)[:-1] != np.array(time_filter)[1:])[0])\n",
    "                        split = parts(latency[trial_index],list(np.array(start_end_inds)+1))\n",
    "                        split2 = parts(Tfilt[trial_index],list(np.array(start_end_inds)+1))\n",
    "                        TfiltSplit = RemoveSlowSequences(split,split2)\n",
    "                        del split[::2] # remove every 2nd item eg. all the latencies that were timefilter = 0 so were too long. \n",
    "                        timesplitlatencies[i] = timesplitlatencies[i] + [TfiltSplit]\n",
    "\n",
    "                # for fragments in each trial,sort and trim so that seqs start at initiation port poke and then remove fragments that are too short. ie. remove any transitions sequences that dont inlcude the first port or are just a single transition.\n",
    "                processed_seqs,processed_latencies = aligntofirstpokeandremovesingletransits(timesplitseqs[0],timesplitlatencies[0])  ## use  timesplitlatencies[0] for Out to in Transition times \n",
    "\n",
    "                ## generate processed transition times dataframe:\n",
    "                Processesed_Transition_Latencies_df,counter1 = generate_processed_transitiontimesdataframe(processed_seqs,processed_latencies,counter1)\n",
    "\n",
    "                ## determine perfect sequences and correspondng training level and shaping parameters\n",
    "                trial_perfects = []\n",
    "                T_CorrectScores = [[],[],[],[]]\n",
    "                T_RepeatScores = [[],[],[],[]]\n",
    "\n",
    "                for trial_index,fragments in enumerate(processed_seqs):\n",
    "                    perfect = []\n",
    "                    for fragment in fragments:\n",
    "                        if sequence_contains_sequence(fragment,[21, 16, 63, 37]):\n",
    "                            perfect = perfect + [1]\n",
    "                        else:\n",
    "                            perfect = perfect + [0]\n",
    "\n",
    "                    trial_perfects = trial_perfects + [perfect]  \n",
    "\n",
    "                # calculate mean for each trial:\n",
    "                perfectscore_trials = []\n",
    "                for trial in trial_perfects:\n",
    "                    if len(trial) == 0:\n",
    "                        perfectscore_trials = perfectscore_trials + [0]\n",
    "                    else:\n",
    "                        perfectscore_trials = perfectscore_trials + [np.mean(trial)]\n",
    "\n",
    "                first_p_ephys_time = sync_data2.FirstPoke_EphysTime.values\n",
    "                first_p_ephys_time = first_p_ephys_time[~np.isnan(first_p_ephys_time)]\n",
    "\n",
    "                fig, ax = plt.subplots(1, 1,figsize=(20,10))\n",
    "                ax.plot(first_p_ephys_time,convolve_movmean(perfectscore_trials,20))\n",
    "                ax.set_xlabel('trials',fontsize = 15)\n",
    "                ax.set_ylabel('performance score',fontsize = 15)\n",
    "                SaveFig('Performance score.png',output_path)\n",
    "\n",
    "                out_df = pd.DataFrame({'ephys_time' : first_p_ephys_time ,\n",
    "                                'Convolved_perfromance_score' : convolve_movmean(perfectscore_trials,20)})\n",
    "\n",
    "                out_df.to_csv(output_path + '/Performance_score.csv')\n",
    "                \n",
    "                if create_intervales_txt:\n",
    "                    if not 'Time_intervales.txt' in os.listdir(output_path):\n",
    "                        ## create a txt file with example intervals for the perfect sequences:\n",
    "                        text = 'Pre_sleep,[[0,100]]\\nPost_sleep,[[200,300]]\\nAwake,[[100,200]]'\n",
    "                        with open(output_path + 'Time_intervales.txt', 'w') as f:\n",
    "                            f.write(text)\n",
    "                \n",
    "            except:\n",
    "                print('no data for this recording')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}