examples/example-1.2.1-brain-exploration-postprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parameter exploration with custom run function and postprocessing\n",
    "\n",
    "This notebook demonstrates how to scan the parameter space of a brain network model  using `neurolib` with a custom evaluation function to quickly find regions of interest. The evaluation function is designed to increase the speed for the exploration by focussing on regions where the simulated dynamics meets certain criteria. For this, the simulation is run in multiple, successive steps, that increase in duration.\n",
    "\n",
    "### Iterative evaluation \n",
    "\n",
    "The evaluation of a simulation takes multiple steps: \n",
    "\n",
    "- Step 1 runs for a few seconds and checks if there is any rate activity at all\n",
    "- Step 2 runs a bit longer and checks if there is any BOLD activity\n",
    "- Step 3 runs the full simulation\n",
    "\n",
    "### Postprocessing\n",
    "\n",
    "In this scenario, we want to postprocess the simulated data as soon as the simulation is done and before writing the results to the hard disk. After the full simulation is run, the funciotnal connectivity (FC) of the BOLD signal is computed and compared to the empirical FC dataset. The Pearson correlation of the FC matrices is computed and the average is taken. We then tell pypet to save these postprocessed results along with the model output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "# change to the root directory of the project\n",
    "import os\n",
    "if os.getcwd().split(\"/\")[-1] == \"examples\":\n",
    "    os.chdir('..')\n",
    "    \n",
    "# This will reload all imports as soon as the code changes\n",
    "%load_ext autoreload\n",
    "%autoreload 2    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "try:\n",
    "    import matplotlib.pyplot as plt\n",
    "except ImportError:\n",
    "    import sys\n",
    "    !{sys.executable} -m pip install matplotlib\n",
    "    import matplotlib.pyplot as plt\n",
    "# a nice color map\n",
    "plt.rcParams['image.cmap'] = 'plasma'\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from neurolib.models.aln import ALNModel\n",
    "from neurolib.utils.parameterSpace import ParameterSpace\n",
    "from neurolib.optimize.exploration import BoxSearch\n",
    "import neurolib.utils.functions as func\n",
    "\n",
    "from neurolib.utils.loadData import Dataset\n",
    "ds = Dataset(\"hcp\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "MainProcess root INFO     aln: Model initialized.\n"
     ]
    }
   ],
   "source": [
    "model = ALNModel(Cmat = ds.Cmat, Dmat = ds.Dmat) # simulates the whole-brain model in 10s chunks by default if bold == True\n",
    "# Resting state fits\n",
    "model.params['mue_ext_mean'] = 1.57\n",
    "model.params['mui_ext_mean'] = 1.6\n",
    "#model.params['sigma_ou'] = 0.09\n",
    "model.params['b'] = 5.0\n",
    "model.params['dt'] = 0.2\n",
    "model.params['duration'] = 0.2 * 1000 #ms\n",
    "# testing: model.params['duration'] = 0.2 * 60 * 1000 #ms\n",
    "# real: model.params['duration'] = 1.0 * 60 * 1000 #ms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define evaluation function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluateSimulation(traj):\n",
    "    # get the model from the trajectory using `search.getModelFromTraj(traj)`\n",
    "    model = search.getModelFromTraj(traj)\n",
    "    # initiate the model with random initial contitions\n",
    "    model.randomICs()\n",
    "    defaultDuration = model.params['duration']\n",
    "    invalid_result = {\"fc\" : np.nan, \"fcd\" : np.nan}\n",
    "    \n",
    "    # -------- STAGEWISE EVALUATION  --------\n",
    "    stagewise = True\n",
    "    if stagewise:\n",
    "        # -------- stage wise simulation --------\n",
    "\n",
    "        # Stage 1 : simulate for a few seconds to see if there is any activity\n",
    "        # ---------------------------------------\n",
    "        model.params['duration'] = 3*1000.\n",
    "        model.run()\n",
    "\n",
    "        # check if stage 1 was successful\n",
    "        amplitude = np.max(model.output[:, model.t > 500]) - np.min(model.output[:, model.t > 500])\n",
    "        if amplitude < 0.05:\n",
    "            search.saveToPypet(invalid_result, traj)\n",
    "            return invalid_result, {}\n",
    "\n",
    "        # Stage 2: simulate BOLD for a few seconds to see if it moves\n",
    "        # ---------------------------------------\n",
    "        model.params['duration'] = 30*1000.\n",
    "        model.run(chunkwise=True, bold = True)\n",
    "\n",
    "        if np.max(np.std(model.outputs.BOLD.BOLD[:, 10:15], axis=1)) < 1e-5:\n",
    "            search.saveToPypet(invalid_result, traj)\n",
    "            return invalid_result, {}\n",
    "    \n",
    "    # Stage 3: full and final simulation\n",
    "    # ---------------------------------------\n",
    "    model.params['duration'] = defaultDuration\n",
    "    model.run(chunkwise=True, bold = True)\n",
    "    \n",
    "    # -------- POSTPROCESSING  --------\n",
    "    # FC matrix correlation to all subject rs-fMRI\n",
    "    BOLD_TRANSIENT = 10000\n",
    "    fc_score = np.mean([func.matrix_correlation(func.fc(model.BOLD.BOLD[:, model.BOLD.t_BOLD > BOLD_TRANSIENT]), fc) for fc in ds.FCs])\n",
    "    \n",
    "    # FCD to all subject rs-fMRI\n",
    "    try:\n",
    "        fcd_score = np.mean([func.ts_kolmogorov(model.BOLD.BOLD[:, model.BOLD.t_BOLD > BOLD_TRANSIENT], ds.BOLDs[i]) for i in range(len(ds.BOLDs))])\n",
    "    except:\n",
    "        fcd_score = np.nan\n",
    "      \n",
    "    # let's build the results dictionary\n",
    "    result_dict = {\"fc\" : fc_score, \"fcd\" : fcd_score}\n",
    "    # we could also save the output of the model by adding to the results_dict like this:\n",
    "    # result_dict = {\"fc\" : fc_score, \"fcd\" : fcd_score, \"outputs\" : model.outputs}\n",
    "    \n",
    "    # Save the results to pypet. \n",
    "    # Remember: This has to be dictionary!\n",
    "    search.saveToPypet(result_dict, traj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up parameter exploration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "MainProcess root INFO     Number of processes: 80\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     I will use the hdf5 file `/mnt/raid/data/cakan/hdf/example-1.2.1.hdf`.\n",
      "MainProcess pypet.environment.Environment INFO     Environment initialized.\n",
      "/home/cakan/anaconda/lib/python3.7/site-packages/pypet/parameter.py:884: FutureWarning: Conversion of the second argument of issubdtype from `str` to `str` is deprecated. In future, it will be treated as `np.str_ == np.dtype(str).type`.\n",
      "  if np.issubdtype(dtype, np.str):\n",
      "MainProcess root INFO     Number of parameter configurations: 4\n",
      "MainProcess root INFO     BoxSearch: Environment initialized.\n"
     ]
    }
   ],
   "source": [
    "parameters = ParameterSpace({\"mue_ext_mean\": np.linspace(0, 3.0, 2), \"mui_ext_mean\": np.linspace(0.2, 3.0, 2)})\n",
    "# info: chose np.linspace(0, 3, 21) or more, values here are low for testing\n",
    "search = BoxSearch(evalFunction = evaluateSimulation, model=model, parameterSpace=parameters, filename=\"example-1.2.1.hdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "MainProcess pypet.environment.Environment INFO     I am preparing the Trajectory for the experiment and initialise the store.\n",
      "MainProcess pypet.environment.Environment INFO     Initialising the storage for the trajectory.\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     Initialising storage or updating meta data of Trajectory `results-2020-04-08-01H-16M-48S`.\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     Finished init or meta data update for `results-2020-04-08-01H-16M-48S`.\n",
      "MainProcess pypet.environment.Environment INFO     \n",
      "************************************************************\n",
      "STARTING runs of trajectory\n",
      "`results-2020-04-08-01H-16M-48S`.\n",
      "************************************************************\n",
      "\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     Initialising storage or updating meta data of Trajectory `results-2020-04-08-01H-16M-48S`.\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     Finished init or meta data update for `results-2020-04-08-01H-16M-48S`.\n",
      "MainProcess pypet.environment.Environment INFO     Starting multiprocessing with at most 80 processes running at the same time.\n",
      "MainProcess pypet INFO     PROGRESS: Finished 0/4 runs [                    ]  0.0%\n",
      "MainProcess pypet INFO     PROGRESS: Finished 1/4 runs [=====               ] 25.0%, remaining: 0:00:02\n",
      "MainProcess pypet INFO     PROGRESS: Finished 2/4 runs [==========          ] 50.0%, remaining: 0:00:00\n",
      "MainProcess pypet INFO     PROGRESS: Finished 3/4 runs [===============     ] 75.0%, remaining: 0:00:09\n",
      "MainProcess pypet INFO     PROGRESS: Finished 4/4 runs [====================]100.0%\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     Initialising storage or updating meta data of Trajectory `results-2020-04-08-01H-16M-48S`.\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     Finished init or meta data update for `results-2020-04-08-01H-16M-48S`.\n",
      "MainProcess pypet.environment.Environment INFO     \n",
      "************************************************************\n",
      "FINISHED all runs of trajectory\n",
      "`results-2020-04-08-01H-16M-48S`.\n",
      "************************************************************\n",
      "\n",
      "MainProcess pypet.environment.Environment INFO     \n",
      "************************************************************\n",
      "STARTING FINAL STORING of trajectory\n",
      "`results-2020-04-08-01H-16M-48S`\n",
      "************************************************************\n",
      "\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     Start storing Trajectory `results-2020-04-08-01H-16M-48S`.\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     Storing branch `config`.\n",
      "/home/cakan/anaconda/lib/python3.7/site-packages/pypet/storageservice.py:4597: FutureWarning: Conversion of the second argument of issubdtype from `str` to `str` is deprecated. In future, it will be treated as `np.str_ == np.dtype(str).type`.\n",
      "  if (np.issubdtype(val.dtype, str) or\n",
      "/home/cakan/anaconda/lib/python3.7/site-packages/pypet/storageservice.py:4598: FutureWarning: Conversion of the second argument of issubdtype from `bytes` to `bytes` is deprecated. In future, it will be treated as `np.bytes_ == np.dtype(bytes).type`.\n",
      "  np.issubdtype(val.dtype, bytes)):\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     Storing branch `parameters`.\n",
      "/home/cakan/anaconda/lib/python3.7/site-packages/pypet/storageservice.py:3110: FutureWarning: Conversion of the second argument of issubdtype from `str` to `str` is deprecated. In future, it will be treated as `np.str_ == np.dtype(str).type`.\n",
      "  np.issubdtype(data.dtype, str)):\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     Finished storing Trajectory `results-2020-04-08-01H-16M-48S`.\n",
      "MainProcess pypet.environment.Environment INFO     \n",
      "************************************************************\n",
      "FINISHED FINAL STORING of trajectory\n",
      "`results-2020-04-08-01H-16M-48S`.\n",
      "************************************************************\n",
      "\n",
      "MainProcess pypet.environment.Environment INFO     All runs of trajectory `results-2020-04-08-01H-16M-48S` were completed successfully.\n"
     ]
    }
   ],
   "source": [
    "search.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "MainProcess root INFO     Loading results from /mnt/raid/data/cakan/hdf/example-1.2.1.hdf\n",
      "/mnt/antares_raid/home/cakan/projects/neurolib/neurolib/utils/pypetUtils.py:21: H5pyDeprecationWarning: The default file mode will change to 'r' (read-only) in h5py 3.0. To suppress this warning, pass the mode you need to h5py.File(), or set the global default h5.get_config().default_file_mode, or set the environment variable H5PY_DEFAULT_READONLY=1. Available modes are: 'r', 'r+', 'w', 'w-'/'x', 'a'. See the docs for details.\n",
      "  hdf = h5py.File(filename)\n",
      "MainProcess root INFO     Analyzing trajectory results-2020-04-08-01H-16M-48S\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     I will use the hdf5 file `/mnt/raid/data/cakan/hdf/example-1.2.1.hdf`.\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     Loading trajectory `results-2020-04-08-01H-16M-48S`.\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     Loading branch `config` in mode `2`.\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     Loading branch `parameters` in mode `2`.\n",
      "MainProcess pypet.storageservice.HDF5StorageService INFO     Loading branch `results` in mode `1`.\n",
      "MainProcess root INFO     Creating pandas dataframe ...\n",
      "MainProcess root INFO     Creating results dictionary ...\n",
      "100%|██████████| 4/4 [00:00<00:00, 219.06it/s]\n",
      "MainProcess root INFO     All results loaded.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of results: 4\n"
     ]
    }
   ],
   "source": [
    "search.loadResults()\n",
    "print(\"Number of results: {}\".format(len(search.results)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>mue_ext_mean</th>\n",
       "      <th>mui_ext_mean</th>\n",
       "      <th>bold_cc</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.174085</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.113122</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0.488884</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.3</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>956</th>\n",
       "      <td>3.0</td>\n",
       "      <td>2.6</td>\n",
       "      <td>-0.223068</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>957</th>\n",
       "      <td>3.0</td>\n",
       "      <td>2.7</td>\n",
       "      <td>-0.220481</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>958</th>\n",
       "      <td>3.0</td>\n",
       "      <td>2.8</td>\n",
       "      <td>-0.232276</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>959</th>\n",
       "      <td>3.0</td>\n",
       "      <td>2.9</td>\n",
       "      <td>-0.182681</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>960</th>\n",
       "      <td>3.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>-0.228365</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>961 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     mue_ext_mean  mui_ext_mean   bold_cc\n",
       "0             0.0           0.0  0.174085\n",
       "1             0.0           0.1  0.113122\n",
       "2             0.0           0.2  0.488884\n",
       "3             0.0           0.3  0.000000\n",
       "4             0.0           0.4  0.000000\n",
       "..            ...           ...       ...\n",
       "956           3.0           2.6 -0.223068\n",
       "957           3.0           2.7 -0.220481\n",
       "958           3.0           2.8 -0.232276\n",
       "959           3.0           2.9 -0.182681\n",
       "960           3.0           3.0 -0.228365\n",
       "\n",
       "[961 rows x 3 columns]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in search.dfResults.index:\n",
    "    search.dfResults.loc[i, 'bold_cc'] = np.mean(search.results[i]['fc'])\n",
    "search.dfResults"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Input to I')"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x600 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(dpi=150)\n",
    "plt.imshow(search.dfResults.pivot_table(values='bold_cc', index = 'mui_ext_mean', columns='mue_ext_mean'), \\\n",
    "           extent = [min(search.dfResults.mue_ext_mean), max(search.dfResults.mue_ext_mean),\n",
    "                     min(search.dfResults.mui_ext_mean), max(search.dfResults.mui_ext_mean)], origin='lower')\n",
    "plt.colorbar(label='Mean correlation to empirical rs-FC')\n",
    "plt.xlabel(\"Input to E\")\n",
    "plt.ylabel(\"Input to I\")"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}