KinematicAnalysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Import Modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import importlib\n",
    "import h5py as h5\n",
    "import pathlib\n",
    "\n",
    "import numpy as np\n",
    "from scipy import signal, stats, interpolate, ndimage\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "import userfunctions as uf\n",
    "import fightclassifier as fac\n",
    "import clusteranalysis as cn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Import Datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "main_path = pathlib.Path().absolute()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "data_name = input('Name of dataset to be used: ')\n",
    "datadir = main_path+data_name\n",
    "data = h5.File(datadir,'r')\n",
    "print(list(data.keys()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "positions = data['tracks_3D_smooth']\n",
    "positions_filt, N_NaN = uf.filt_trajectories(positions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Compute kinematic variables and behavioral states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## If datasets not available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "Single_v,Comp_v = fac.kinematic_analysis(positions_filt[:],0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "State_dict = fac.fight_analysis(Single_v,Comp_v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Compute ethogram_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "len_p = len(positions_filt)\n",
    "n_states_in_dict = 6\n",
    "\n",
    "State_array = np.zeros((n_states_in_dict,len_p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "State_array[0] = State_dict['passive display']\n",
    "State_array[1] = State_dict['circling']\n",
    "State_array[2] = State_dict['aggressive state'][:,0]\n",
    "State_array[3] = State_dict['aggressive state'][:,1]\n",
    "State_array[4] = State_dict['freezing'][:,0]\n",
    "State_array[5] = State_dict['freezing'][:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "ethogram_array = fac.compute_etho_array(State_array,100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## If datasets available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-30T16:03:09.909626Z",
     "start_time": "2021-03-30T16:02:59.738449Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "single_v_name = input('Name of dataset with single fish variables: ') #with .h5\n",
    "svdir = main_path + single_v_name\n",
    "Single_v = h5.File(svdir,'r')\n",
    "\n",
    "joint_v_name = input('Name of dataset with joint variables: ') #with .h5\n",
    "jvdir = main_path + joint_v_name\n",
    "Comp_v = h5.File(jvdir,'r')\n",
    "\n",
    "state_v_name = input('Name of dataset with compound behavioral states: ') #with .h5\n",
    "stdir = main_path + state_v_name\n",
    "ethogram_dict = h5.File(stdir,'r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Save computed datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Save single variables "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "dataset_name = input('Name of dataset to be saved: ')\n",
    "dataset_name = dataset_name + '.h5'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "bevstate = h5.File(dataset_name,'w')\n",
    "bevstate.create_dataset('distance',data=Single_v['distance'])\n",
    "bevstate.create_dataset('speed',data=Single_v['speed'])\n",
    "bevstate.create_dataset('heading',data=Single_v['heading'])\n",
    "bevstate.create_dataset('z position',data=Single_v['z position'])\n",
    "bevstate.create_dataset('tail beat rate',data=Single_v['tail beat rate'])\n",
    "bevstate.create_dataset('tail z bend',data=Single_v['tail z bend'])\n",
    "bevstate.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Save joint variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "dataset_name = input('Name of dataset to be saved: ')\n",
    "dataset_name = dataset_name + '.h5'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "bevstate = h5.File(dataset_name,'w')\n",
    "bevstate.create_dataset('average distance',data=Comp_v['average distance'])\n",
    "bevstate.create_dataset('mean speed',data=Comp_v['mean speed'])\n",
    "bevstate.create_dataset('alignment',data=Comp_v['alignment'])\n",
    "bevstate.create_dataset('acc alignment',data=Comp_v['acc alignment'])\n",
    "bevstate.create_dataset('mean tail beating rate',data=Comp_v['mean tail beating rate'])\n",
    "bevstate.create_dataset('var tail beating rate',data=Comp_v['var tail beating rate'],axis=1))\n",
    "bevstate.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Save compound behav states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "dataset_name = input('Name of dataset to be saved: ')\n",
    "dataset_name = dataset_name + '.h5'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "bevstate = h5.File(dataset_name,'w')\n",
    "bevstate.create_dataset('Passive display',data=ethogram_array[0])\n",
    "bevstate.create_dataset('Active display',data=ethogram_array[1])\n",
    "bevstate.create_dataset('Sym Fight',data=ethogram_array[2])\n",
    "bevstate.create_dataset('Asym Fight',data=ethogram_array[3])\n",
    "bevstate.create_dataset('Freeze',data=ethogram_array[4])\n",
    "bevstate.create_dataset('Other',data=ethogram_array[5])\n",
    "bevstate.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Analysis of compound behavioral states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Variable averages in different compound behavioral states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "comp_v_array = np.zeros((6,len_p))\n",
    "comp_v_array[0] = Comp_v['average distance']\n",
    "comp_v_array[1] = Comp_v['mean speed']\n",
    "comp_v_array[2] = np.arcos(Comp_v['alignment'])\n",
    "comp_v_array[3] = np.arcos(Comp_v['acc alignment'])\n",
    "comp_v_array[4] = Comp_v['mean tail beating rate']/(2*np.pi)\n",
    "comp_v_array[5] = Comp_v['var tail beating rate']/(2*np.pi)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "comp_v_avg = cn.cluster_bev_avg(comp_v_array,ethogram_array.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Behavioral states as a function of tail beat rate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "att_state,tb_bins = uf.bin_xy(comp_v_array[4]/(2*np.pi),np.sum(ethogram_array[2:4],axis=0),500)\n",
    "freeze_state,tb_bins = uf.bin_xy(comp_v_array[4]/(2*np.pi),ethogram_array[4],500)\n",
    "disp_state,tb_bins = uf.bin_xy(comp_v_array[4]/(2*np.pi),np.sum(ethogram_array[:2],axis=0),500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "state_vec = np.zeros((400,3))\n",
    "state_vec[:,0] = disp_state[:400]/np.max(disp_state[:400])\n",
    "state_vec[:,1] = att_state[:400]/np.max(att_state[:400])\n",
    "state_vec[:,2] = freeze_state[:400]/np.max(att_state[:400])\n",
    "\n",
    "sum_st = np.sum(state_vec,axis=1)\n",
    "state_vec1 = np.zeros(state_vec.shape)\n",
    "state_vec1[:,0] = state_vec[:,0]/sum_st\n",
    "state_vec1[:,1] = state_vec[:,1]/sum_st\n",
    "state_vec1[:,2] = state_vec[:,2]/sum_st"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Fit generalized linear models to the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "beta_ag, alpha_ag = uf.gen_linear_mod_fit(tb_bins[100:200],state_vec1[100:200,1])\n",
    "beta_fr, alpha_fr = uf.gen_linear_mod_fit(tb_bins[30:100],state_vec1[30:100,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "f_ag= 1/(1+np.exp(-beta_ag*tb_bins+alpha_ag))\n",
    "f_fr = 1/(1+np.exp(-beta_fr*tb_bins+alpha_fr))\n",
    "f_dsp = 1 - f_ag - f_fr\n",
    "\n",
    "w_ag = -alpha_ag/beta_ag\n",
    "w_fr = -alpha_fr/beta_fr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Behavioral states as a function of tail beat rate and distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "Atk_r, dist_r,z_r = uf.bin_xyz(comp_v_array[0],comp_v_array[4],np.sum(ethogram_array[2:4],axis=0),50)\n",
    "Frz_r, dist_r,z_r = uf.bin_xyz(comp_v_array[0],comp_v_array[4],ethogram_array[4],50)\n",
    "Dsp_r, dist_r,z_r = uf.bin_xyz(comp_v_array[0],comp_v_array[4],np.sum(ethogram_array[:2],axis=0),50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "H_dtb = np.histogram2d(comp_v_array[0],comp_v_array[4],bins=50)[0]\n",
    "H_f = ndimage.gaussian_filter(H_dtb,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Deviation of the tail beat rate and synchronization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "w = Single_v['tail beat rate']\n",
    "phase = np.zeros(w.shape)\n",
    "dt = 0.01\n",
    "for i in range(2):\n",
    "    phase[:,i] = np.cumsum(w[:,i])*dt\n",
    "    \n",
    "sig1 = np.exp(1j*phase)\n",
    "sig_fut = sig1[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# Build a linear model\n",
    "win_mod = 3000\n",
    "B_vec, r_vec, Corr_v, Corr_est = uf.LinModv1(np.real(sig1[:-1]),np.real(sig_fut),win_mod)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "b_coef = B_vec[:,1:,0]/dt\n",
    "A_coef = B_vec[:,1:,1:]\n",
    "K_est = (1-np.linalg.det(A_coef))/(dt)\n",
    "\n",
    "w_avg = comp_v_array[4]\n",
    "w_var = comp_v_array[5]\n",
    "w_dev_500 = w_var[:]**0.5/w_avg[:]\n",
    "\n",
    "w_wind = []\n",
    "for i in range(len(phase)//win_mod):\n",
    "    w_wind.append(np.median(w_dev_500[i*win_mod:(i+1)*win_mod]))\n",
    "w_wind = np.array(w_wind)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "smooth_w = uf.windowed_average(w_wind,3)\n",
    "smooth_k = uf.windowed_average(K_est,3)\n",
    "\n",
    "W_fit, K_fit = uf.bin_xy(smooth_k,smooth_w,25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "ppwk = np.histogram2d(K_est,w_wind,50)\n",
    "fwk = ndimage.gaussian_filter(ppwk[0],2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Visualization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Display ethogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(16,4))\n",
    "plt.pcolormesh(np.arange(6),np.arange(len_p),np.log(ethogram_array),cmap='Blues')\n",
    "plt.gca().invert_yaxis()\n",
    "plt.yticks(np.arange(6),['d1','d2','a1','a2','f','o'])\n",
    "plt.title('Ethogram')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Averages of variables in different states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "N = len(ethogram_array)\n",
    "\n",
    "plt.figure(figsize=(16,8))\n",
    "plt.subplot(231)\n",
    "plt.bar(np.arange(1,N+1),avg_var[4],alpha=0.5,yerr=avg_var[4]/10,color='gold')\n",
    "plt.title('Mean 2$\\pi\\omega(s^{-1})$',fontsize=20)\n",
    "plt.xticks(np.arange(1,N+1),['d1','d2','a1','a2','o'])\n",
    "plt.grid()\n",
    "\n",
    "plt.subplot(232)\n",
    "plt.bar(np.arange(1,N+1),avg_var[0],alpha=0.5,yerr=avg_var[0]/10,color='orangered')\n",
    "plt.title('distance (bl)',fontsize=20)\n",
    "plt.xticks(np.arange(1,N+1),['d1','d2','a1','a2','o'])\n",
    "plt.grid()\n",
    "\n",
    "plt.subplot(233)\n",
    "plt.bar(np.arange(1,N+1),avg_var[3],alpha=0.5,yerr=avg_var[3]/10,color='cornflowerblue')\n",
    "plt.title('speed (bl/s)',fontsize=20)\n",
    "plt.xticks(np.arange(1,N+1),['d1','d2','a1','a2','o'])\n",
    "plt.grid()\n",
    "\n",
    "plt.subplot(234)\n",
    "plt.bar(np.arange(1,N+1),avg_var[1],alpha=0.5,yerr=avg_var[1]/10,color='green')\n",
    "plt.xticks(np.arange(1,N+1),['d1','d2','a1','a2','o'])\n",
    "plt.title('alignment',fontsize=20)\n",
    "\n",
    "plt.subplot(235)\n",
    "plt.bar(np.arange(1,N+1),avg_var[2],alpha=0.5,yerr=avg_var[2]/10,color='limegreen')\n",
    "plt.xticks(np.arange(1,N+1),['d1','d2','a1','a2','o'])\n",
    "plt.title('Acc. alignment',fontsize=20)\n",
    "\n",
    "plt.subplot(236)\n",
    "plt.bar(np.arange(1,N+1), avg_var[5], alpha=0.5,yerr=avg_var[5]/10,color='goldenrod')\n",
    "plt.title('Dev $\\omega$',fontsize=20)\n",
    "plt.xticks(np.arange(1,N+1),['d1','d2','a1','a2','o'])\n",
    "plt.plot\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Beh. states as functions of tail beat, with fits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(16,8))\n",
    "\n",
    "plt.plot(tb_bins,f_dsp,'--',color='green')\n",
    "plt.plot(tb_bins,f_ag,'--',color='orangered')\n",
    "plt.plot(tb_bins,f_fr,'--',color='blue')\n",
    "\n",
    "plt.plot(tb_bins,frz_state[:])\n",
    "plt.plot(tb_bins,agg_state[:])\n",
    "plt.plot(tb_bins,disp_state[:])\n",
    "\n",
    "plt.ylim(0,1)\n",
    "plt.grid()\n",
    "\n",
    "plt.legend(['Display','Aggressive state','Freezing'],fontsize=16)\n",
    "plt.xlabel('$\\\\hat{\\omega}$ $(s^{-1})$ ',fontsize=20)\n",
    "plt.title('Relative frequency (fitted)', fontsize=22)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Deviation of tail beat rate in function of the coupling between the pair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "plt.contourf(ppwk[1][:-1],ppwk[2][:-1],fwk.T,cmap='jet')\n",
    "plt.plot(K_fit,W_fit,'k')\n",
    "plt.xlabel('Coupling constant',fontsize=16)\n",
    "plt.ylabel('Tail beat Deviation',fontsize=16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Beh. States as function of tail beat and distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(20,5))\n",
    "\n",
    "D = ndimage.gaussian_filter(Dsp_r,1)\n",
    "A = ndimage.gaussian_filter(Atk_r,1)\n",
    "F = ndimage.gaussian_filter(Frz_r,1)\n",
    "\n",
    "plt.subplot(131)\n",
    "plt.title('Display',fontsize=16)\n",
    "plt.contourf(dist_r,z_r,D/np.sum(D),cmap='jet')\n",
    "plt.xlabel('Distance (bl)')\n",
    "plt.ylabel('Mean $\\omega$ ($s^{-1}$)')\n",
    "plt.colorbar()\n",
    "\n",
    "plt.subplot(132)\n",
    "plt.title('Aggressive state',fontsize=16)\n",
    "plt.contourf(dist_r,z_r,A/np.sum(A),cmap='jet')\n",
    "plt.colorbar()\n",
    "plt.xlabel('Distance (bl)')\n",
    "plt.ylabel('Mean $\\omega$ ($s^{-1}$)')\n",
    "\n",
    "plt.subplot(133)\n",
    "plt.title('Freezing',fontsize=16)\n",
    "plt.contourf(dist_r,z_r,F/np.sum(F),cmap='jet')\n",
    "plt.colorbar()\n",
    "plt.xlabel('Distance (bl)')\n",
    "plt.ylabel('Mean $\\omega$ ($s^{-1}$)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "plt.contourf(dist_r,z_r/(2*np.pi),(H_f.T)/np.sum(H_f),15,cmap='jet')\n",
    "plt.xlabel('Distance (bl)')\n",
    "plt.ylabel('Mean $\\omega$ ($s^{-1}$)')\n",
    "plt.title('Histogram',fontsize=16)\n",
    "plt.colorbar()"
   ]
  }
 ],
 "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.6.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}