{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Tutorial: Population Level Modeling (with PopNet)\n", "\n", "In this tutorial we will focus on modeling of populations and population firing rates. This is done with the PopNet simulator application of BMTK which uses the [DiPDE](https://github.com/AllenInstitute/dipde) engine as a backend. We will first build our networks using the BMTK [NetworkBuilder](https://alleninstitute.github.io/bmtk/builder.html) and save them into the [SONATA data format](https://github.com/AllenInstitute/sonata/tree/master). Then we will show how to simulate the firing rates over a given interval.\n", "\n", "Requirements:\n", "* BMTK\n", "* DiPDE\n", "\n", "Scripts for running this tutorial can be found in the directory [sources/chapter06](https://github.com/AllenInstitute/bmtk/tree/develop/docs/tutorial/sources/chapter06).\n", "\n", "For more information on BMTK and SONATA format, please see the [Overview of BMTK](https://alleninstitute.github.io/bmtk/user_guide.html) and [Network Builder](https://alleninstitute.github.io/bmtk/builder.html) pages." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Building the network\n", "\n", "\n", "#### Option 1: Converting existing networks\n", "Like BioNet for biophysically detailed modeling and PointNet with point-based networks, PopNet works with networks in the SONATA data format. PopNet supports simulating networks of individual cells at the population level. The first thing you have to do is modify the node-types and edge-types of an existing network to use Population level models (rather than models of individual cells). \n", "\n", "
\n", "**WARNING** - Converting a network of individual nodes into population of nodes is good for a quick and naive simulation, but for faster and more reliable results it's best to build a network from scratch (next section).\n", "
\n", "\n", "[See the SONATA users guide for details](https://github.com/AllenInstitute/sonata/blob/master/docs/SONATA_DEVELOPER_GUIDE.md#neuron_networks_nodes) of a network set to work with BioNet (for an example of the BioNet network, see [tutorial 3](https://alleninstitute.github.io/bmtk/tutorials/tutorial_03_single_pop.html)): " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
node_type_ideimorphology_filemodel_processingpop_namelocationmodel_templatemodel_typedynamics_params
0100eScnn1a.swcaibs_perisomaticScnn1aL4ctdb:Biophys1.hocbiophysical472363762_fit.json
1101iPvalb.swcaibs_perisomaticPVL4ctdb:Biophys1.hocbiophysical472912177_fit.json
2102eNaNNaNLIF_excVisL4nrn:IntFire1point_processIntFire1_exc_1.json
3103iNaNNaNLIF_inhVisL4nrn:IntFire1point_processIntFire1_inh_1.json
\n", "
" ], "text/plain": [ " node_type_id ei morphology_file model_processing pop_name location \\\n", "0 100 e Scnn1a.swc aibs_perisomatic Scnn1a L4 \n", "1 101 i Pvalb.swc aibs_perisomatic PV L4 \n", "2 102 e NaN NaN LIF_exc VisL4 \n", "3 103 i NaN NaN LIF_inh VisL4 \n", "\n", " model_template model_type dynamics_params \n", "0 ctdb:Biophys1.hoc biophysical 472363762_fit.json \n", "1 ctdb:Biophys1.hoc biophysical 472912177_fit.json \n", "2 nrn:IntFire1 point_process IntFire1_exc_1.json \n", "3 nrn:IntFire1 point_process IntFire1_inh_1.json " ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandas as pd\n", "\n", "pd.read_csv('sources/chapter06/converted_network/V1_node_types_bionet.csv', sep=' ')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "versus the equivalent form for PopNet:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
node_type_ideimorphology_filemodel_processingpop_namelocationmodel_templatemodel_typedynamics_params
0100eNaNNaNScnn1aL4dipde:Internalpopulation472363762_pop.json
1101iNaNNaNPVL4dipde:Internalpopulation472912177_pop.json
2102eNaNNaNLIF_excVisL4dipde:InternalpopulationIntFire1_exc_pop.json
3103iNaNNaNLIF_inhVisL4dipde:InternalpopulationIntFire1_inh_pop.json
\n", "
" ], "text/plain": [ " node_type_id ei morphology_file model_processing pop_name location \\\n", "0 100 e NaN NaN Scnn1a L4 \n", "1 101 i NaN NaN PV L4 \n", "2 102 e NaN NaN LIF_exc VisL4 \n", "3 103 i NaN NaN LIF_inh VisL4 \n", "\n", " model_template model_type dynamics_params \n", "0 dipde:Internal population 472363762_pop.json \n", "1 dipde:Internal population 472912177_pop.json \n", "2 dipde:Internal population IntFire1_exc_pop.json \n", "3 dipde:Internal population IntFire1_inh_pop.json " ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pd.read_csv('sources/chapter06/converted_network/V1_node_types_popnet.csv', sep=' ')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Some things to note:\n", "* Each node in the network now corresponds to a a population rather than a cell, and therefore **model_type** is node \"population\", rather than individual biophysical/point types\n", "* We have set **model_template** to dipde:Internal which will tell the simulator to use special DiPDE model types\n", "* We are using new **dynamic_params** files with parameters that have been adjusted to appropiate range for DiPDE models.\n", "* **morophology_file** and **model_processing**, which were used to set and processes individual cell morphologies, are no longer applicable.\n", "\n", "[See SONATA specification for edges css files here](https://github.com/AllenInstitute/sonata/blob/master/docs/SONATA_DEVELOPER_GUIDE.md#neuron_networks_edges). Finally, when we run the simulation we must tell PopNet to cluster nodes together using the **group_by** property:\n", "\n", "```python\n", "network = popnet.PopNetwork.from_config(configure, group_by='node_type_id')\n", "```\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Option 2: Building a network from scratch\n", "\n", "We will create a network of two populations: one population of excitatory cells and another of inhibitory cells. Then we will save the network into SONATA-formatted data files.\n", "\n", "The first step is to use the [NetworkBuilder](https://alleninstitute.github.io/bmtk/builder.html#) to instantiate a new network with two populations:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from bmtk.builder import NetworkBuilder\n", "\n", "\n", "net = NetworkBuilder('V1')\n", "net.add_nodes(\n", " pop_name='excitatory', # name of specific population optional\n", " ei='e', # Optional\n", " location='VisL4', # Optional\n", " model_type='population', # Required, indicates what types of cells are being model\n", " model_template='dipde:Internal', # Required, instructs what DiPDE objects will be created\n", " dynamics_params='exc_model.json' # Required, contains parameters used by DiPDE during initialization of object\n", ")\n", "\n", "net.add_nodes(\n", " pop_name='inhibitory',\n", " ei='i',\n", " model_type='population',\n", " model_template='dipde:Internal',\n", " dynamics_params='inh_model.json'\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next we will create connections between the two populations:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "net.add_edges(\n", " source={'ei': 'e'}, target={'ei': 'i'},\n", " syn_weight=0.005,\n", " nsyns=20,\n", " delay=0.002,\n", " dynamics_params='ExcToInh.json'\n", ")\n", "\n", "net.add_edges(\n", " source={'ei': 'i'}, target={'ei': 'e'},\n", " syn_weight=-0.002,\n", " nsyns=10,\n", " delay=0.002,\n", " dynamics_params='InhToExc.json'\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "and finally we must build and save the network:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "net.build()\n", "net.save(output_dir='sim_ch06/network')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### External Nodes\n", "\n", "The *dipde:Internal* nodes we created need input to fire, so we will use External Populations to drive the network activity. To do this we will create a separate network of 'virtual' populations, or alternativly use model_type=dipde:External, that connect to our excitatory population. \n", "\n", "Note: we could add 'virtual' populations directly to our V1 network. However, creating them as a separate network provides a great advantage if/when we want to replace our external connections with a different model (or if we want to remove the reccurrent connections and simulate with feed-foward activity only)." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "input_net = NetworkBuilder('LGN')\n", "input_net.add_nodes(\n", " pop_name='tON',\n", " ei='e',\n", " model_type='virtual'\n", ")\n", "\n", "input_net.add_edges(\n", " target=net.nodes(ei='e'),\n", " syn_weight=0.0025,\n", " nsyns=10,\n", " delay=0.002,\n", " dynamics_params='input_ExcToExc.json'\n", ")\n", "\n", "input_net.build()\n", "input_net.save(output_dir='sim_ch06/network')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Setting up the PopNet environment\n", "\n", "Before running the simulation we need to set up our simulation environment. This includes setting up run-scripts, configuration parameters, and placing our parameter files in their appropriate location. The easiest way to do this is through the command-line:\n", "\n", "```bash\n", "$ python -m bmtk.utils.sim_setup -n network --tstop 1500.0 popnet sim_ch06/\n", "```\n", "\n", "The function [`bmtk.utils.sim_setup`](https://alleninstitute.github.io/bmtk/_modules/bmtk/utils/sim_setup.html) creates initial files to run a 1500 ms simulation (`--tstop 1500.00`) of the population network (`popnet`) using the network files found in our ./network directory (`-n network`) under the main directory (`sim_ch06/`).\n", "\n", "#### Inputs\n", "\n", "We next need to set the firing rates of the External Population. There are multiple ways to set this value which will be discussed later. The best way is to set the firing rates using a input-rates file for each External Population. We can fetch an input-rates existing file using the command:\n", "\n", "```bash\n", " $ cd sim_ch06\n", " $ wget https://github.com/AllenInstitute/bmtk/raw/develop/examples/pop_2pops/inputs/external_rates.csv -O lgn_rates.csv\n", "\n", "```\n", "\n", "Then we must open the simulation_config.json file with a text editor and add the lgn_rates.csv file as a part of our inputs:\n", "\n", "```json\n", "{\n", " \"inputs\": {\n", " \"LGN_pop_rates\": {\n", " \"input_type\": \"csv\",\n", " \"module\": \"pop_rates\",\n", " \"rates\": \"${BASE_DIR}/lgn_rates.csv\",\n", " \"node_set\": \"LGN\"\n", " }\n", " }\n", "}\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Running the simulation\n", "\n", "The call to sim_setup created a file run_pointnet.py that we can run directly in a command line:\n", "```bash\n", "$ python run_popnet.py config.json\n", "```\n", "It takes one argument, config.json, which contains the simulation parameters specified during the previous steps.\n", "\n", "Alternatively, we can run it directly using the following python code:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2022-08-09 16:50:15,020 [INFO] Created log file\n", "2022-08-09 16:50:15,054 [INFO] Building cells.\n", "2022-08-09 16:50:15,055 [INFO] Building recurrent connections\n", "2022-08-09 16:50:15,059 [INFO] Build virtual cell stimulations for LGN_pop_rates\n", "2022-08-09 16:50:15,078 [INFO] Network created.\n", "2022-08-09 16:50:15,080 [INFO] Running simulation.\n", "2022-08-09 16:50:18,766 [INFO] Finished simulation.\n" ] } ], "source": [ "from bmtk.simulator import popnet\n", "\n", "configure = popnet.config.from_json('sim_ch06/config.json')\n", "configure.build_env()\n", "network = popnet.PopNetwork.from_config(configure)\n", "sim = popnet.PopSimulator.from_config(configure, network)\n", "sim.run()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. Analyzing the results\n", "\n", "As specified in the \"output\" section of the simulation_config.json file, the results will be written to ouput/spike_rates.csv. The BMTK analyzer includes code for plotting and analyzing the firing rates of our network:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from bmtk.analyzer.firing_rates import plot_rates_popnet\n", "\n", "plot_rates_popnet('sim_ch06/network/V1_node_types.csv', 'sim_ch06/output/firing_rates.csv', model_keys='pop_name')" ] }, { "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.10.13" } }, "nbformat": 4, "nbformat_minor": 4 }