{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Tutorial: Single Cell Simulation with External Feedforward Input (with BioNet)\n", "\n", "In the previous tutorial we built a single cell and stimulated it with a current injection. In this example we will keep our single-cell network, but instead of stimulation by a step current, we'll set-up an external network that synapses onto our cell.\n", "\n", "**Note** - scripts and files for running this tutorial can be found in the directory [sources/chapter02/](https://github.com/AllenInstitute/bmtk/tree/develop/docs/tutorial/sources/chapter02)\n", "\n", "**Requirements:**\n", "* Python 2.7 or 3.6+\n", "* bmtk\n", "* NEURON 7.4+\n", "\n", "For more information on the BioNet Simulator, please see the [BioNet Overview](https://alleninstitute.github.io/bmtk/bionet.html).\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", "Similar to the [previous tutorial](tutorial_01_single_cell_clamped.ipynb) (see for description of input parameters), we want to build and save a network consisting of a single biophysically detailed cell. " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from bmtk.builder.networks import NetworkBuilder\n", "\n", "# Main network\n", "cortex = NetworkBuilder('mcortex')\n", "cortex.add_nodes(\n", " cell_name='Scnn1a_473845048',\n", " potental='exc',\n", " model_type='biophysical',\n", " model_template='ctdb:Biophys1.hoc',\n", " model_processing='aibs_perisomatic',\n", " dynamics_params='472363762_fit.json',\n", " morphology='Scnn1a_473845048_m.swc'\n", ")\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "cortex.build()\n", "cortex.save_nodes(output_dir='sim_ch02/network')" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true } }, "source": [ "Next we will create a collection of external spike-generating cells that will synapse onto our cell. To do this we create a second network which can represent some external inputs (such as input from the thalamus to our cortical cell). We will call our network \"mthalamus\", and it will consist of 10 cells. These cells are not biophysical but instead \"virtual\" cells. Virtual cells don't have a morphology or the normal properties of a neuron, but rather act as spike generators." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# Input network\n", "thalamus = NetworkBuilder('mthalamus')\n", "thalamus.add_nodes(\n", " N=10,\n", " pop_name='tON',\n", " potential='exc',\n", " model_type='virtual'\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we built our nodes (cells), we want to create a connection between our 10 thalamic cells onto our cortex cell. To do so we use the `add_edges` function like so:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Connect the input network to the main network\n", "thalamus.add_edges(\n", " source={'pop_name': 'tON'}, target=cortex.nodes(),\n", " connection_rule=5,\n", " syn_weight=0.001,\n", " delay=2.0,\n", " weight_function=None,\n", " target_sections=['basal', 'apical'],\n", " distance_range=[0.0, 150.0],\n", " dynamics_params='AMPA_ExcToExc.json',\n", " model_template='exp2syn'\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let us break down how this method call works:\n", "```python\n", "thalamus.add_edges(source={'pop_name': 'tON'}, target=cortex.nodes(),\n", "```\n", "* Here we specify which set of nodes to use as sources and targets. Our source/pre-synaptic cells are all thalmus cells with the property \"pop_name=tON\", which in this case is every thalamus cell (We could also use `source=thalamus.nodes()`, or `source={'level_of_detail': 'filter'}`). The target/post-synaptic cells are all cell(s) of the \"cortex\" network.\n", "\n", "```python\n", "connection_rule=5,\n", "```\n", "* The *connection_rule* parameter determines how many synapses exist between every source/target pair. In this very trivial case we are indicating that for every thalamic --> cortical cell connection, there are 5 synapses. In future tutorials we will show how we can create more complex customized rules.\n", "\n", "```python\n", "syn_weight=0.001,\n", "delay=2.0,\n", "weight_function=None,\n", "```\n", "* Here we are specifying the connection weight. For every connection in this edge-type, there is a strength of 1e-03 and a synaptic delay of 2 ms. The weight function is used to adjust the weights before runtime. Later we will show how to create customized weight functions.\n", "\n", "```python\n", " target_sections=['basal', 'apical'],\n", " distance_range=[0.0, 150.0],\n", "```\n", "\n", "* This is used by BioNet to determine where on the post-synaptic cell to place the synapse. By default placement is random within the given section and range.\n", "```python\n", "dynamics_params='AMPA_ExcToExc.json', \n", "model_template='exp2syn')\n", "```\n", "* The *dynamics_params* file contains the parameters of the synapse, including the time constant and potential. Here we are using an AMPA type synaptic model with an Excitatory connection. The *model_template* parameter is used by BioNet to convert the model into a valid NEURON synaptic object.\n", "\n", "Finally we are ready to build the model and save the thalamic nodes and edges." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "thalamus.build()\n", "thalamus.save_nodes(output_dir='sim_ch02/network')\n", "thalamus.save_edges(output_dir='sim_ch02/network')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The network/ directory will contain multiple nodes and edges files. It should have nodes (and node-types) files for both the thalamus and cortex network. And edges (and edge-types) files for the thalamus --> cortex connections. Nodes and edges for different networks and their connections are spread out across different files which allows us in the future to rebuild, edit or replace part of setup in a piecemeal and efficient manner." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Spike Trains\n", "\n", "We need to give our 10 thalamic cells spike trains. There are multiple ways to do this, but an easy way is to use a sonata hdf5 file. The following function will create a file to provide the spikes for our 10 cells:\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "from bmtk.utils.reports.spike_trains import PoissonSpikeGenerator\n", "\n", "psg = PoissonSpikeGenerator(population='mthalamus')\n", "psg.add(\n", " node_ids=range(10), # Have 10 nodes to match mthalamus\n", " firing_rate=10.0, # 10 Hz, we can also pass in a nonhomoegenous function/array\n", " times=(0.0, 3.0) # Firing starts at 0 s up to 3 s\n", ")\n", "psg.to_sonata('sim_ch02/inputs/mthalamus_spikes.h5')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The spikes files are save as a [Sonata formated spikes train](https://github.com/AllenInstitute/sonata/blob/master/docs/SONATA_DEVELOPER_GUIDE.md#spike-file). BMTK also allows CSV files and NWB files to set the spike train - we just have to specify the appropriate format in the configuration file (see bottom of tutorial for an example)." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of spikes: 315\n", "Units: ms\n" ] }, { "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", "
node_idstimestampspopulation
0045.327109mthalamus
1077.644564mthalamus
20163.482462mthalamus
30517.296866mthalamus
40535.154362mthalamus
\n", "
" ], "text/plain": [ " node_ids timestamps population\n", "0 0 45.327109 mthalamus\n", "1 0 77.644564 mthalamus\n", "2 0 163.482462 mthalamus\n", "3 0 517.296866 mthalamus\n", "4 0 535.154362 mthalamus" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print('Number of spikes: {}'.format(psg.n_spikes()))\n", "print('Units: {}'.format(psg.units()))\n", "\n", "psg.to_dataframe().head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2: Setting up BioNet environment\n", "\n", "### File structure:\n", "\n", "Before running a simulation, we will need to create the runtime environment, including parameter files, run-script and configuration files. If using the tutorial these files will already be in place, however you should run the following anyway in a command-line:\n", "\n", "```bash\n", "$ python -m bmtk.utils.sim_setup \\\n", " --report-vars v,cai \\ \n", " --network sim_ch02/network \\ \n", " --spikes-inputs mthalamus:sim_ch02/inputs/mthalamus_spikes.h5 \\\n", " --dt 0.1 \\\n", " --tstop 3000.0 \\ \n", " --include-examples \\\n", " --compile-mechanisms \\ \n", " bionet sim_ch02\n", "```\n", "\n", "Or call the function directly in python:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from bmtk.utils.sim_setup import build_env_bionet\n", "\n", "build_env_bionet(\n", " base_dir='sim_ch02',\n", " config_file='config.json',\n", " network_dir='sim_ch02/network',\n", " tstop=3000.0, dt=0.1,\n", " report_vars=['v', 'cai'], # Record membrane potential and calcium (default soma)\n", " spikes_inputs=[('mthalamus', # Name of population which spikes will be generated for\n", " 'sim_ch02/inputs/mthalamus_spikes.h5')],\n", " include_examples=True, # Copies components files\n", " compile_mechanisms=True # Will try to compile NEURON mechanisms\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Add input network parameters to config file:\n", "\n", "The last thing that we need to do is to update the configuration file to read the **thalamus_spikes.csv** as input. To do so we open **simulation_config.json** in a text editor and add the following to the **input** section:\n", "\n", "```json\n", "{\n", " \"inputs\": {\n", " \"mthalamus_spikes\": {\n", " \"input_type\": \"spikes\",\n", " \"module\": \"sonata\",\n", " \"input_file\": \"${BASE_DIR}/input/mthalamus_spikes.csv\",\n", " \"node_set\": \"mthalamus\"\n", " }\n", " }\n", "}\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Running the simulation\n", "\n", "Once our config file is setup we can run a simulation either through the command line:\n", "```bash\n", "$ cd sim_ch02/\n", "$ python run_bionet.py config.json\n", "```\n", "\n", "or through the script:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2022-08-08 16:06:48,667 [INFO] Created log file\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Created log file\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "numprocs=1\n", "2022-08-08 16:06:48,750 [INFO] Building cells.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Building cells.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-08-08 16:06:48,919 [INFO] Building recurrent connections\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Building recurrent connections\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-08-08 16:06:48,922 [INFO] Building virtual cell stimulations for mthalamus_spikes\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Building virtual cell stimulations for mthalamus_spikes\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-08-08 16:06:48,955 [INFO] Running simulation for 3000.000 ms with the time step 0.100 ms\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Running simulation for 3000.000 ms with the time step 0.100 ms\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-08-08 16:06:48,956 [INFO] Starting timestep: 0 at t_sim: 0.000 ms\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Starting timestep: 0 at t_sim: 0.000 ms\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-08-08 16:06:48,957 [INFO] Block save every 5000 steps\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Block save every 5000 steps\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-08-08 16:06:49,289 [INFO] step:5000 t_sim:500.00 ms\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils: step:5000 t_sim:500.00 ms\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-08-08 16:06:49,582 [INFO] step:10000 t_sim:1000.00 ms\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils: step:10000 t_sim:1000.00 ms\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-08-08 16:06:49,881 [INFO] step:15000 t_sim:1500.00 ms\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils: step:15000 t_sim:1500.00 ms\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-08-08 16:06:50,176 [INFO] step:20000 t_sim:2000.00 ms\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils: step:20000 t_sim:2000.00 ms\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-08-08 16:06:50,495 [INFO] step:25000 t_sim:2500.00 ms\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils: step:25000 t_sim:2500.00 ms\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-08-08 16:06:50,800 [INFO] step:30000 t_sim:3000.00 ms\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils: step:30000 t_sim:3000.00 ms\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2022-08-08 16:06:50,808 [INFO] Simulation completed in 1.853 seconds \n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:NEURONIOUtils:Simulation completed in 1.853 seconds \n" ] } ], "source": [ "from bmtk.simulator import bionet\n", "\n", "\n", "conf = bionet.Config.from_json('sim_ch02/config.json')\n", "conf.build_env()\n", "net = bionet.BioNetwork.from_config(conf)\n", "sim = bionet.BioSimulator.from_config(conf, network=net)\n", "sim.run()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. Analyzing the run" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of Spikes: 57\n" ] }, { "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", "
timestampsnode_idspopulation
045.00mcortex
11375.10mcortex
21532.40mcortex
31686.90mcortex
41780.40mcortex
\n", "
" ], "text/plain": [ " timestamps node_ids population\n", "0 45.0 0 mcortex\n", "1 1375.1 0 mcortex\n", "2 1532.4 0 mcortex\n", "3 1686.9 0 mcortex\n", "4 1780.4 0 mcortex" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from bmtk.analyzer.spike_trains import to_dataframe\n", "\n", "results_df = to_dataframe(config_file='sim_ch02/config.json')\n", "print('Number of Spikes: {}'.format(len(results_df)))\n", "results_df.head()" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from bmtk.analyzer.compartment import plot_traces\n", "\n", "_ = plot_traces(config_file='sim_ch02/config.json', node_ids=[0], report_name='v_report')\n", "_ = plot_traces(config_file='sim_ch02/config.json', node_ids=[0], report_name='cai_report')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5. Additional information\n", "\n", "### Changing edge properties\n", "\n", "When using the Network Builder `add_edges` method, we gave all the edges the same parameter values (delay, weight, target_section, etc.). All connections created by this method call constitute a single edge-type that share the same parameters, and are specified in the **mthalamic_edge_type.csv** file:" ] }, { "cell_type": "code", "execution_count": 12, "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", "
edge_type_idtarget_querysource_querymodel_templateweight_functiontarget_sectionsdelaydynamics_paramssyn_weightdistance_range
0100*pop_name=='tON'exp2synNaN['basal', 'apical']2.0AMPA_ExcToExc.json0.001[0.0, 150.0]
\n", "
" ], "text/plain": [ " edge_type_id target_query source_query model_template weight_function \\\n", "0 100 * pop_name=='tON' exp2syn NaN \n", "\n", " target_sections delay dynamics_params syn_weight distance_range \n", "0 ['basal', 'apical'] 2.0 AMPA_ExcToExc.json 0.001 [0.0, 150.0] " ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandas as pd\n", "pd.read_csv('sim_ch02/network/mthalamus_mcortex_edge_types.csv', sep=' ')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "(if in the build script called `add_edges` multiple times, we'd have multiple edge-types). \n", "\n", "Using a simple text-editor, we can modify this file directly or change parameters before a simulation run without having to rebuild the entire network (although for a network this small it may not be beneficial).\n", "\n", "### Weight function\n", "\n", "By default BioNet uses the value in *syn_weight* to set a synaptic weight, which is a constant stored in the network files. Often we will want to adjust the synaptic weight between simulations, but don't want to have to regenerate the network. BioNet allows us to specify custom synaptic weight functions that will calculate the synaptic weight before each simulation. \n", "\n", "To do so first we must set the value of 'weight_function' column. Either we can open up the file **mthalamus_mcortex_edge_types.csv** with a text-editor and change the column. \n", "\n", "\n", "|edge_type_id | target_query | source_query | ... | weight_function |\n", "|-------------|--------------|----------------|-----|-----------------|\n", "|100 | * |pop_name=='tON' | ... |*adjusted_weight* |\n", "\n", "or we can rebuild the edges:\n", "```python\n", "thalamus.add_edges(source={'pop_name': 'tON'}, target=cortex.nodes(),\n", " connection_rule=5,\n", " syn_weight=0.001,\n", " weight_function=adjusted_weight,\n", " delay=2.0,\n", " target_sections=['basal', 'apical'],\n", " distance_range=[0.0, 150.0],\n", " dynamics_params='AMPA_ExcToExc.json',\n", " model_template='exp2syn')\n", "```\n", "\n", "Then we write a custom weight function. The weight functions will be called during the simulation when building each synapse, and requires three parameters - target_cell, source_cell, and edge_props. These three parameters are dictionaries which can be used to access properties of the source node, target node, and edge, respectively. The function must return a floating point number which will be used to set the synaptic weight:\n", "\n", "```python\n", "def adjusted_weights(target_cell, source_cell, edge_props):\n", " if target_cell['cell_name'] == 'Scnn1a':\n", " return edge_prop[\"weight_max\"]*0.5\n", " elif target_cell['cell_name'] == 'Rorb'\n", " return edge_prop[\"weight_max\"]*1.5\n", " else:\n", " ...\n", "```\n", "\n", "Finally we must tell BioNet where to access the function which we can do by using the add_weight_function:\n", "```python\n", "from bmtk.simulator import bionet\n", "\n", "bionet.nrn.add_weight_function(adjusted_weights)\n", "\n", "conf = bionet.Config.from_json('config.json')\n", "...\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Using NWB files to set spike trains\n", "\n", "Instead of using CSV files to set the spike trains of our external network, we can also use [NWB files](https://nwb-schema.readthedocs.io/en/latest/format_description.html). The typical setup would look like the following in the config file:\n", "\n", "```json\n", "{\n", " \"inputs\": {\n", " \"LGN_spikes\": {\n", " \"input_type\": \"spikes\",\n", " \"module\": \"nwb\",\n", " \"input_file\": \"$INPUT_DIR/lgn_spikes.nwb\",\n", " \"node_set\": \"lgn\",\n", " \"trial\": \"trial_0\"\n", " },\n", " }\n", "}\n", "```" ] } ], "metadata": { "anaconda-cloud": {}, "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 }