NM2020_Ann.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "NM2020_Ann.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "COGQuDb43S1J",
        "colab_type": "text"
      },
      "source": [
        "Note: This notebook contains only PCA-related functions written by me, and other essential helper functions to perform the trail-grouped PCA. \n",
        "I eliminated all the other EDA done by the original codes, so that it's cleaner to read and is easier to incorporate into one big file in the end.\n",
        "The HeatMapTSegXBrainReg function from Pixel is modified a little bit by adding another input argument, so that it becomes more generalized. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bEqdz1ZUMaj1",
        "colab_type": "text"
      },
      "source": [
        "## Loading of Steinmetz data\n",
        "\n",
        "includes some visualizations"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TLWjKq8bLDqm",
        "colab_type": "code",
        "cellView": "both",
        "colab": {}
      },
      "source": [
        "# Data retrieval\n",
        "import os, requests\n",
        "\n",
        "fname = []\n",
        "for j in range(3):\n",
        "  fname.append('steinmetz_part%d.npz'%j)\n",
        "url = [\"https://osf.io/agvxh/download\"]\n",
        "url.append(\"https://osf.io/uv3mw/download\")\n",
        "url.append(\"https://osf.io/ehmw2/download\")\n",
        "\n",
        "for j in range(len(url)):\n",
        "  if not os.path.isfile(fname[j]):\n",
        "    try:\n",
        "      r = requests.get(url[j])\n",
        "    except requests.ConnectionError:\n",
        "      print(\"!!! Failed to download data !!!\")\n",
        "    else:\n",
        "      if r.status_code != requests.codes.ok:\n",
        "        print(\"!!! Failed to download data !!!\")\n",
        "      else:\n",
        "        with open(fname[j], \"wb\") as fid:\n",
        "          fid.write(r.content)\n"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sffzC_hyLgWZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "b364c9d1-1ecf-4478-dd4c-9fc20f70f637"
      },
      "source": [
        "# Data loading\n",
        "import numpy as np\n",
        "\n",
        "alldat = np.array([])\n",
        "for j in range(len(fname)):\n",
        "  alldat = np.hstack((alldat, np.load('steinmetz_part%d.npz'%j, allow_pickle=True)['dat']))\n",
        "\n",
        "# select just one of the recordings here. 11 is nice because it has some neurons in vis ctx. \n",
        "dat = alldat[11]\n",
        "print(dat.keys())"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "dict_keys(['spks', 'wheel', 'pupil', 'response', 'response_time', 'bin_size', 'stim_onset', 'contrast_right', 'contrast_left', 'brain_area', 'feedback_time', 'feedback_type', 'gocue', 'mouse_name', 'date_exp', 'trough_to_peak', 'active_trials', 'contrast_left_passive', 'contrast_right_passive', 'spks_passive', 'pupil_passive', 'wheel_passive', 'prev_reward', 'ccf', 'ccf_axes', 'cellid_orig', 'reaction_time', 'face', 'face_passive', 'licks', 'licks_passive'])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M7HV6PQHsRCD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "0a591f06-df4b-49b9-f91f-5b2e127cf17b"
      },
      "source": [
        "dat['spks'].shape\n",
        "NN = len(dat['brain_area'])\n",
        "response = dat['response'] \n",
        "vis_right = dat['contrast_right'] \n",
        "vis_left = dat['contrast_left']\n",
        "is_correct = np.sign(response)==np.sign(vis_left-vis_right)\n",
        "large_margin = np.abs(vis_right - vis_left) > 0.49\n",
        "print(\"correct:\"+ str(np.sum(is_correct)))\n",
        "print(\"incorrect:\"+ str(np.sum(~is_correct)))\n",
        "print(\"large margin:\" + str(np.sum(large_margin)))\n",
        "print(\"small margin:\"+ str(np.sum(~large_margin)))"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "correct:236\n",
            "incorrect:104\n",
            "large margin:165\n",
            "small margin:175\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5K7UT7dyj_6R",
        "colab_type": "text"
      },
      "source": [
        "`alldat` contains 39 sessions from 10 mice, data from Steinmetz et al, 2019. Time bins for all measurements are 10ms, starting 500ms before stimulus onset. The mouse had to determine which side has the highest contrast. For each `dat = alldat[k]`, you have the following fields:\n",
        "\n",
        "* `dat['mouse_name']`: mouse name\n",
        "* `dat['date_exp']`: when a session was performed\n",
        "* `dat['spks']`: neurons by trials by time bins.    \n",
        "* `dat['brain_area']`: brain area for each neuron recorded. \n",
        "* `dat['contrast_right']`: contrast level for the right stimulus, which is always contralateral to the recorded brain areas.\n",
        "* `dat['contrast_left']`: contrast level for left stimulus. \n",
        "* `dat['gocue']`: when the go cue sound was played. \n",
        "* `dat['response_times']`: when the response was registered, which has to be after the go cue. The mouse can turn the wheel before the go cue (and nearly always does!), but the stimulus on the screen won't move before the go cue.  \n",
        "* `dat['response']`: which side the response was (`-1`, `0`, `1`). When the right-side stimulus had higher contrast, the correct choice was `-1`. `0` is a no go response. \n",
        "* `dat['feedback_time']`: when feedback was provided. \n",
        "* `dat['feedback_type']`: if the feedback was positive (`+1`, reward) or negative (`-1`, white noise burst).  \n",
        "* `dat['wheel']`: exact position of the wheel that the mice uses to make a response, binned at `10ms`. \n",
        "* `dat['pupil']`: pupil area  (noisy, because pupil is very small) + pupil horizontal and vertical position. \n",
        "* `dat['lfp']`: recording of the local field potential in each brain area from this experiment, binned at `10ms`.\n",
        "* `dat['brain_area_lfp']`: brain area names for the LFP channels. \n",
        "* `dat['trough_to_peak']`: measures the width of the action potential waveform for each neuron. Widths `<=10` samples are \"putative fast spiking neurons\". \n",
        "* `dat['waveform_w']`: temporal components of spike waveforms. `w@u` reconstructs the time by channels action potential shape. \n",
        "* `dat['waveform_u]`: spatial components of spike waveforms.\n",
        "* `dat['%X%_passive']`: same as above for `X` = {`spks`, `lfp`, `pupil`, `wheel`, `contrast_left`, `contrast_right`} but for  passive trials at the end of the recording when the mouse was no longer engaged and stopped making responses. \n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "raBVOEWgUK_B",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# import matplotlib and set defaults\n",
        "from matplotlib import rcParams \n",
        "from matplotlib import pyplot as plt\n",
        "rcParams['figure.figsize'] = [20, 4]\n",
        "rcParams['font.size'] =15\n",
        "rcParams['axes.spines.top'] = False\n",
        "rcParams['axes.spines.right'] = False\n",
        "rcParams['figure.autolayout'] = True"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JYhiUDTi1uAZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# groupings of brain regions\n",
        "regions = [\"vis ctx\", \"thal\", \"hipp\", \"other ctx\", \"midbrain\", \"basal ganglia\", \"cortical subplate\", \"other\"]\n",
        "brain_groups = [[\"VISa\", \"VISam\", \"VISl\", \"VISp\", \"VISpm\", \"VISrl\"], # visual cortex\n",
        "                [\"CL\", \"LD\", \"LGd\", \"LH\", \"LP\", \"MD\", \"MG\", \"PO\", \"POL\", \"PT\", \"RT\", \"SPF\", \"TH\", \"VAL\", \"VPL\", \"VPM\"], # thalamus\n",
        "                [\"CA\", \"CA1\", \"CA2\", \"CA3\", \"DG\", \"SUB\", \"POST\"], # hippocampal\n",
        "                [\"ACA\", \"AUD\", \"COA\", \"DP\", \"ILA\", \"MOp\", \"MOs\", \"OLF\", \"ORB\", \"ORBm\", \"PIR\", \"PL\", \"SSp\", \"SSs\", \"RSP\",\" TT\"], # non-visual cortex\n",
        "                [\"APN\", \"IC\", \"MB\", \"MRN\", \"NB\", \"PAG\", \"RN\", \"SCs\", \"SCm\", \"SCig\", \"SCsg\", \"ZI\"], # midbrain\n",
        "                [\"ACB\", \"CP\", \"GPe\", \"LS\", \"LSc\", \"LSr\", \"MS\", \"OT\", \"SNr\", \"SI\"], # basal ganglia \n",
        "                [\"BLA\", \"BMA\", \"EP\", \"EPd\", \"MEA\"] # cortical subplate\n",
        "                ]\n",
        "\n",
        "nareas = 4 # only the top 4 regions are in this particular mouse\n",
        "NN = len(dat['brain_area']) # number of neurons\n",
        "barea = nareas * np.ones(NN, ) # last one is \"other\"\n",
        "for j in range(nareas):\n",
        "  barea[np.isin(dat['brain_area'], brain_groups[j])] = j # assign a number to each region"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YWksczF8vzTV",
        "colab_type": "text"
      },
      "source": [
        "# Helper Functions\n",
        "Note: Clamp427, VarHunter427 and HeatMap are provided by Pixel"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-tr7ufS8o3IT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import copy\n",
        "\n",
        "def smooth_dat(dat):\n",
        "  \"\"\" Given a session of data: dat\n",
        "      return the smoothed data, which is the firing rate for each recorded neuron\n",
        "      by convolving the raw spikes counts data with a 1d gaussian filter\n",
        "  Args:\n",
        "    dat(dict): one session of data\n",
        "  Return:\n",
        "    dat_rate (dict): a deep copy of input data, with its raw spike counts data replaced\n",
        "    by the spking rate data after convoling\n",
        "  \"\"\"\n",
        "\n",
        "  dat_smoothed = copy.deepcopy(dat)\n",
        "  for i in range(dat_smoothed['spks'].shape[0]):\n",
        "    for j in range(dat_smoothed['spks'].shape[1]):\n",
        "      spks = copy.deepcopy(dat['spks'][i][j])\n",
        "      dat_smoothed['spks'][i][j] = np.convolve(spks, gaussian, 'same')\n",
        "\n",
        "  return dat_smoothed\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CKvFsVTsmrv6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def Clamp427(val,min_val,max_val):\n",
        "   return max(min(val,max_val),min_val)\n",
        "   \n",
        "def VarHunter427(dat, trial_ave = None, time_seg = None, nPC = 4):\n",
        "  \"\"\" Given a session of data: dat\n",
        "      print out variance explained using PCA on spike data by brain sub-regions\n",
        "  Args:\n",
        "    dat (np.arr):\n",
        "      dat = alldat[s] s:= session number\n",
        "    trial_ave (arr like object):\n",
        "      trial number to average over; if None, then stack all time steps along all trials\n",
        "    time_seg (slice object): # first 80 bins = 1.6 sec\n",
        "      specify the slice of time (3rd dim in dat['spks']) over which PCA is done\n",
        "    nPC (int):\n",
        "      number of principal components\n",
        "  Return:\n",
        "\n",
        "  \"\"\"\n",
        "  nTimebins = dat['spks'].shape[-1] # number of bins\n",
        "  if time_seg == None:\n",
        "    time_seg == slice(51,130) # default\n",
        "  list_var = list() # list of lists\n",
        "  list_tot = list() # list of floats\n",
        "  list_PC_NN = list() # list of len 2 tuples storing nPC and NN_\n",
        "  brain_arr = list(set(dat['brain_area'])) # all unique brain_areas\n",
        "  for str_ in brain_arr: # iterate over all unique brain_areas\n",
        "      filter_ = np.isin(dat['brain_area'], [str_])\n",
        "      NN_ = filter_.sum()\n",
        "      # stack all of the time bins along trials (collapse dim 1 and 2)\n",
        "      droll = np.reshape(dat['spks'][filter_][:,:,time_seg], (NN_,-1))\n",
        "      droll = droll - np.mean(droll, axis=1)[:, np.newaxis]\n",
        "      nPC = Clamp427(nPC, 0, min(droll.shape[0],droll.shape[1])) # 0: n_features, 1: n_samples\n",
        "      model = PCA(n_components = nPC).fit(droll.T)\n",
        "      W = model.components_\n",
        "      pc_10ms = W @ np.reshape(dat['spks'][filter_], (NN_,-1))\n",
        "      pc_10ms = np.reshape(pc_10ms, (nPC, -1, nTimebins))\n",
        "      variance_perc = model.explained_variance_ratio_\n",
        "      tot_var = np.sum(variance_perc)\n",
        "      list_var.append(variance_perc)\n",
        "      list_tot.append(tot_var)\n",
        "      list_PC_NN.append((nPC, droll.shape[0]))\n",
        "  list_var = np.array(list_var)\n",
        "  list_tot = np.array(list_tot)\n",
        "  brain_arr = np.array(brain_arr)\n",
        "  list_PC_NN = np.array(list_PC_NN)\n",
        "\n",
        "  by_totnPC = np.argsort(list_tot)[::-1] # descending order\n",
        "  list_var = list_var[by_totnPC]\n",
        "  list_tot = list_tot[by_totnPC]\n",
        "  brain_arr = brain_arr[by_totnPC]\n",
        "  list_PC_NN = list_PC_NN[by_totnPC]\n",
        "  for i in range(len(list_tot)):\n",
        "      print('region: ', brain_arr[i].ljust(5), 'PC:n_features ' \\\n",
        "            , list_PC_NN[i][0], ':', str(list_PC_NN[i][1]).ljust(4) \\\n",
        "            , 'total: %.3f' %list_tot[i], 'var explained: ', list_var[i])\n",
        "  "
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6RxKAr7HGTl3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def HeatMapTSegXBrainReg(PCperSlice_regions, brain_arr, x_labels, choice_PC = [0,1,2,3]):\n",
        "  \"\"\"\n",
        "    Args:\n",
        "    PCperSlice_regions (np.arr; (nSlice, nPC, len(brain_arr)):\n",
        "      nSlice: slice of data on which PCA is performed (x-axis of the heatmaps)\n",
        "      nPC: number of PC = number of heatmaps\n",
        "      len(brain_arr): number of regions after collapsing all neurons into subgroups\n",
        "    brain_arr (list):\n",
        "      string name for brain regions / or str(index) for each neuron in given region\n",
        "      (in the latter case the y-axis will just be all neurons in given region)\n",
        "      size of which should be equal to the PCperSlice_regions.shape[2]\n",
        "    x_labels (list):\n",
        "      string name for different trails groups on the x-axis\n",
        "    choice_PC (1D array like object):\n",
        "      PC index to display heat map on\n",
        "  \"\"\"\n",
        "  xLen = PCperSlice_regions.shape[0] # x is time segment slices\n",
        "  yLen = PCperSlice_regions.shape[2] # y is brain region\n",
        "  \n",
        "  #fig, ax = plt.subplots() # create a plot\n",
        "  fig, axs = plt.subplots(1, len(choice_PC), figsize=(20, 9))\n",
        "  # do min(4,nPC) components\n",
        "  for pc in range(len(choice_PC)):\n",
        "    theMatrix = PCperSlice_regions[:,choice_PC[pc],:].T # transpose it\n",
        "    im = axs[pc].imshow(theMatrix)\n",
        "    # show all ticks & labels\n",
        "    \"\"\"\n",
        "    # Create colorbar\n",
        "    cbar_kw = {}\n",
        "    cbar = fig.colorbar(im, ax=axs[pc], **cbar_kw)\n",
        "    cbar.ax.set_ylabel('PC weights', rotation=-90, va=\"bottom\")\n",
        "    \"\"\"\n",
        "    axs[pc].set_xticks(np.arange(xLen))\n",
        "    axs[pc].set_yticks(np.arange(yLen))\n",
        "    axs[pc].set_xticklabels(x_labels)\n",
        "    axs[pc].set_yticklabels(brain_arr)\n",
        "    # Rotate the tick labels and set their alignment\n",
        "    plt.setp(axs[pc].get_xticklabels(), rotation=70, ha=\"right\", rotation_mode=\"anchor\")\n",
        "    # Loop over data dimensions and create text annotations\n",
        "    \"\"\"\n",
        "    for y in range(yLen): # row of theMatrix\n",
        "        for x in range(xLen): # col of theMatrix\n",
        "            text = axs[pc].text(x, y, theMatrix[y, x],\n",
        "                          ha=\"center\", va=\"center\", color=\"w\")\n",
        "    \"\"\"\n",
        "    axs[pc].set_title(\"PC {p:.0f}\".format(p = choice_PC[pc] + 1))\n",
        "  # Create colorbar\n",
        "  clb = fig.colorbar(im, ax=axs.ravel().tolist(), shrink = 0.42)\n",
        "  clb.ax.set_ylabel('PC weights', rotation=-90, va=\"bottom\")\n",
        "  clb.ax.set_anchor((1,0.5))\n",
        "  #fig.tight_layout()\n",
        "  plt.show()"
      ],
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B2fHkBgbmY6I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "VarHunter427(dat)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x08qPQpSv6Hf",
        "colab_type": "text"
      },
      "source": [
        "# PCA by Trail Groups"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ImrElubEMWCV",
        "colab_type": "text"
      },
      "source": [
        "Note: \n",
        "1. VarHunter could be used to do sanity check on the variance explained\n",
        "2. Y-axis of the heat map: brain regions could be sorted by the magnitude of the weights or by number of neurons"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NNrZpJwPq1Ve",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.decomposition import PCA \n",
        "\n",
        "def FindNumOfNeurons(dat):\n",
        "  \"\"\" Given one session, returns the number of neurons in each\n",
        "      of the brain regions it records from.\n",
        "  Args:\n",
        "      dat (dict): contains all recording information from one single session,\n",
        "                  including the brain area of each recorded neuron.\n",
        "  Return:\n",
        "      NN (dict): a dictionary contains all the recorded brain regions in one session\n",
        "                 as the key, and number of neurons in each of these regions\n",
        "  \"\"\"\n",
        "\n",
        "  barea = dat['brain_area']\n",
        "  NN = {}\n",
        "  for i in range(len(barea)):\n",
        "    if barea[i] not in NN:\n",
        "      NN[barea[i]] = 0\n",
        "    NN[barea[i]] += 1\n",
        "  return NN\n",
        "\n",
        "\n",
        "\n",
        "def PCAbyTrailGroup(spks, n_component):\n",
        "  \"\"\" Given dat, perform PCA on its spks\n",
        "  Args: \n",
        "      spks\n",
        "  Return:\n",
        "      W (list, shape(n_component, n_neurons)): \n",
        "      weights of PCs with our specified number of components, \n",
        "  \"\"\"\n",
        "  droll = np.reshape(spks[:,:,51:130], (NN,-1)) # first 80 bins = 1.6 sec\n",
        "  droll = droll - np.mean(droll, axis=1)[:, np.newaxis]\n",
        "  model = PCA(n_component).fit(droll.T)\n",
        "  W = model.components_\n",
        "  return W\n",
        "\n",
        "\n",
        "\n",
        "def Region_Averaged_PC_weights(W, params):\n",
        "  \"\"\" Given the weights of all PCs of interest, compute the brain region-averaged \n",
        "      PC weights for each of the PC.\n",
        "  Args:\n",
        "      W ((n_component, NN) array): weights of PCs of interest\n",
        "      params (dict): contains a list of brain area and a list of number of neurons in each area\n",
        "  Return:\n",
        "      w_by_region ((n_component, num_brain_area) array)\n",
        "  \"\"\" \n",
        "  barea = params['barea']\n",
        "  num_neurons = params['num_neurons']\n",
        "  w_by_region = []\n",
        "  for PC in W:\n",
        "    w_per_PC = []\n",
        "    for area in barea:\n",
        "      local_neurons = dat['brain_area'] == area \n",
        "      w_per_PC.append(np.sum(local_neurons * PC))\n",
        "    for i in range(len(w_per_PC)):\n",
        "      w_per_PC[i] /= num_neurons[i]\n",
        "    w_by_region.append(w_per_PC)\n",
        "  return barea, w_by_region\n"
      ],
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xs1R89Mn17pS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def PCA_HeatMap_by_TrailGroup(dat):\n",
        "  \"\"\" Given dat, first seperate all trails to correct/incorrect, large/small margin groups,\n",
        "      then perform a PCA on each of these four conditions, and produce a heatmap on brain\n",
        "      region averaged weights of PC for correct/incorrect, and large/small margin group.\n",
        "  Args:\n",
        "      dat (dict): one session of recording.\n",
        "  Returns:\n",
        "      Two groups of heatmaps performed on correct/incorrect trails, and large/small margin \n",
        "      trails, respectively. Each group of heatmap contains 4 seperate heatmaps corresponding \n",
        "      to top 4 PCs sorted by descending variance explained. The Y-axis of each heatmap\n",
        "      labels different brain regions in the input session, sorted by descending number of \n",
        "      recorded neurons. The X-axis is different trail groups. \n",
        "  \"\"\"\n",
        "\n",
        "  # preprocessing for PCA\n",
        "  spks = dat['spks']\n",
        "  response = dat['response']\n",
        "  vis_left = dat['contrast_left']\n",
        "  vis_right = dat['contrast_right']\n",
        "  is_correct = np.sign(response)==np.sign(vis_left-vis_right)\n",
        "  large_margin = np.abs(vis_left - vis_right) > 0.49\n",
        "\n",
        "  # perform PCA on each of correct/incorrect, large/small margin trails\n",
        "  # plotting the variance explained by the top few PCs\n",
        "  w_cor = PCAbyTrailGroup(spks[:, is_correct, :], 4)        # PCA on correct trail group\n",
        "  w_incor = PCAbyTrailGroup(spks[:, ~is_correct, :], 4)     # PCA on incorrect trail group\n",
        "  w_lar_margin = PCAbyTrailGroup(spks[:, large_margin, :], 4)   # PCA on large margin trial group\n",
        "  w_smal_margin = PCAbyTrailGroup(spks[:, ~large_margin, :], 4) # PCA on small margin trail group\n",
        "\n",
        "  # sort both the weights and the barea by descending number of neurons within each region\n",
        "  barea_dict = FindNumOfNeurons(dat)\n",
        "  barea_keys = list(FindNumOfNeurons(dat).keys())\n",
        "  barea = []\n",
        "  num_neurons = sorted(FindNumOfNeurons(dat).values(), reverse=True)  # sort the number of neurons\n",
        "  for i in range(len(num_neurons)):\n",
        "    for j in range(len(barea_keys)):\n",
        "      if barea_dict[barea_keys[j]] == num_neurons[i]:\n",
        "        barea.append(barea_keys[j])\n",
        "  params = {'barea': barea, 'num_neurons': num_neurons}\n",
        "\n",
        "  # average PC weights by brain regions for each of four trail groups\n",
        "  barea_cor, w_cor_aver     =  Region_Averaged_PC_weights(w_cor, params)\n",
        "  barea_incor, w_incor_aver =  Region_Averaged_PC_weights(w_incor, params)\n",
        "  barea_lar, w_lar_aver     =  Region_Averaged_PC_weights(w_lar_margin, params)\n",
        "  barea_smal, w_smal_aver   =  Region_Averaged_PC_weights(w_smal_margin, params)\n",
        "\n",
        "  # converting region-averaged weights to Heatmap\n",
        "  w_cor_incor = np.array([w_cor_aver, w_incor_aver])\n",
        "  w_lar_smal_margin = np.array([w_lar_aver, w_smal_aver])\n",
        "  x_label_cor = ['correct', 'incorrect']\n",
        "  x_label_mar = ['large margin', 'small margin']\n",
        "  HeatMapTSegXBrainReg(w_cor_incor, barea, x_label_cor, choice_PC = [0,1,2,3])\n",
        "  HeatMapTSegXBrainReg(w_lar_smal_margin, barea, x_label_mar, choice_PC = [0,1,2,3])"
      ],
      "execution_count": 49,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N0VorL8kO7IO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "52ba6c2d-6f1c-484b-dacc-bbf02b51a67d"
      },
      "source": [
        "PCA_HeatMap_by_TrailGroup(dat)"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/IPython/core/pylabtools.py:125: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n",
            "  fig.canvas.print_figure(bytes_io, **kw)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x648 with 5 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x648 with 5 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}