{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Tools for Modeling: The Brain Modeling Toolkit and SONATA data format\n", "\n", "source: https://github.com/AllenInstitute/bmtk/tree/develop/docs/tutorial/modeling_tut_2021\n", "\n", "This tutorial will show how to build and simulate a toy model of the mouse V1 cortical area network using the Brain Modeling Toolkit (BMTK) [\\[Dai et al., PLOS Comp. Bio., 2020\\]](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1008386), including how to modify and simulate larger more realistic visual cortical models released by the Allen Institute [\\[Billeh et al., Neuron, 2020\\]](https://www.cell.com/neuron/pdf/S0896-6273(20)30067-2.pdf). The tutorial will also briefly explain the SONATA data format [\\[Dai et al., PLOS Comp. Bio., 2020\\]](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1007696) and how the BMTK uses the format to describe network models, simulations and results.\n", "\n", "In this tutorial we will show how to build and simulate a modestly sized toy network based on the layer 4 of the mouse primary Visual cortex (V1) (which is the primary layer of the V1 for receiving thalamic stimulus). The L4 model [\\[Arkhipov et al., PLOS Comp. Bio., 2018\\]](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1006535), further described [here](https://portal.brain-map.org/explore/models/l4-mv1), contains 45,000+ cells and millions of connections: \n", "\n", "<img src=\"_static/images/layer4_side_view.png\" alt=\"Drawing\" style=\"width: 300px; float: left\"/>\n", "<img src=\"_static/images/layer4_angled_view.png\" alt=\"Drawing\" style=\"width: 300px; float: left\"/>" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Building and running the actual L4 model can take many hours and will require access to high-performance computing (HPC) resources. The toy model we will build and simulate will have only 300 cells to allow us to build and simulate the model in a few minutes for most desktop and laptop machines.\n", "\n", "For more information about cortical modeling and simulation at the Allen Institute:\n", "see: https://portal.brain-map.org/explore/models\n", "\n", "For more information and tutorials on using the BMTK:\n", "see: https://alleninstitute.github.io/bmtk" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Installing BMTK\n", "[\\[https://alleninstitute.github.io/bmtk/installation.html\\]](https://alleninstitute.github.io/bmtk/installation.html)\n", "\n", "BMTK will require python 2.7 or 3.6+. You can clone the latest developement branch from https://github.com/AllenInstitute/bmtk.git. \n", "\n", "```bash\n", " $ https://github.com/AllenInstitute/bmtk\n", " $ cd bmtk\n", " $ python setup.py install\n", "```\n", "\n", "\n", "Alternatively one can install using python's pip utility:\n", "\n", "```bash\n", " $ pip install bmtk\n", "```\n", "\n", "Or if you're using a CONDA environment:\n", "\n", "```bash\n", " $ conda install -c kaeldai bmtk\n", "```\n", "\n", "For simulation [NEURON](https://www.neuron.yale.edu/neuron/) will also be required to be installed (including python bindings). To quickly install NEURON on your machine:\n", "```bash\n", " $ pip install neuron\n", "```\n", "\n", "or \n", "```\n", " $ conda install -c conda-forge neuron\n", "```\n", "\n", "\n", "### The BMTK Docker Image\n", "\n", "We have included a docker image that will come with BMTK, neuron, and a ready-to-use jupyter notebook server with this tutorial and it's content already installed. To run the docker image\n", "\n", "```bash\n", " ## Linux or OSX\n", " $ docker run -v $(pwd):/home/shared/workspace -p 8888:8888 alleninstitute/bmtk jupyter\n", " \n", " ## Windows PowerShell\n", " $ docker run -v ${PWD}:/home/shared/workspace -p 8888:8888 alleninstitute/bmtk jupyter\n", "```\n", "\n", "Then open a web browser to __127.0.0.1:8888/__. This current tutorial can be found under the folder *tutorials/modeling_tut_2021/Mouse_L4.ipynb*." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Building the Network\n", "\n", "<img src=\"_static/images/bmtk_workflow_builder.png\" style=\"width: 700px; float: left\"/>" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Before we can start simulation we must first build (or receive from a third party) the network model files. To create our toy network of 300 cells in BMTK we will use the *builder* component, which allows us to build heterogeneous, multi-graph networks and save them in the SONATA format.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Building the cells\n", "<img src=\"_static/images/builder_add_nodes.png\" style=\"width: 350px; float: left\"/>" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first step is figuring out different cell types and parameters we want to use in our network. When we know that we can begin building our network model first by initializing the network using _bmtk.builder.networks.NetworkBuilder_ plus calls to _add_nodes()_ method" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "from bmtk.builder.networks import NetworkBuilder\n", "\n", "# intialize a new population of cells called \"V1\"\n", "v1 = NetworkBuilder('V1')\n", "\n", "# Add a population of 80 \"Scnn1a\" type nodes\n", "v1.add_nodes(\n", " N=80,\n", " \n", " # Reserved SONATA keywords used during simulation\n", " model_type='biophysical',\n", " model_template='ctdb:Biophys1.hoc',\n", " dynamics_params='472363762_fit.json',\n", " morphology='Scnn1a_473845048_m.swc',\n", " model_processing='aibs_perisomatic',\n", " \n", " # The x, y, z locations of each cell in a column\n", " x=np.random.normal(0.0, 20.0, size=80),\n", " y=np.random.uniform(400.0, 500.0, size=80),\n", " z=np.random.normal(0.0, 20.0, size=80),\n", " \n", " # Euler rotations of the cells\n", " rotation_angle_xaxis=np.random.uniform(0.0, 2*np.pi, size=80),\n", " rotation_angle_yaxis=np.random.uniform(0.0, 2*np.pi, size=80),\n", " rotation_angle_zaxis=-3.646878266,\n", " \n", " # Optional parameters\n", " tuning_angle=np.linspace(start=0.0, stop=360.0, num=80, endpoint=False),\n", " pop_name='Scnn1a',\n", " location='L4',\n", " ei='e',\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The above call to add_nodes() will add __N=80__ different individual cells to our network. \n", "\n", "The attributes __model_type__, __model_template__, __dynamics_params__, __model_processing__ and __morphology__ are SONATA reserved keywords that will instruct BMTK (or other SONATA compliant tools) how to build cell models during the simulation. In this model we are using biophysically realistic models, with dynamical parameters (.json) and morphology (.swc) that we can download from the [Allen Cell Types Database](https://celltypes.brain-map.org/data). We have already downloaded the required json and swc files and have saved them under *components/biophysical_neuron_templates* and \n", "*components/morphologies/*, respectively.\n", "\n", "Attributes __x__, __y__, __z__ are used as the euclidian locations of the cells, while the __rotation_angle__ parameters are used to orentate the cells. Note that for the x and y rotations we are passing in an array of size N, but the z rotation is defined by a scalar. SONATA and the BMTK Network Builder allows us to differentiate between attributes that are unique to each cell versus shared attributes. Each of the 80 cells will have unique x and y rotations, but share the same pre-calculated z rotation.\n", "\n", "The final remaining attributes are not reserved SONATA keywords, but rather optional attributes that will be helpful during analysis. The __tuning_angle__ property (the angle in the visual space that a given cell is intended to prefer with respect to its visual responses) is an attribute that in this model is set for excitatory but not inhibitory cells. It wouldn't be applicable to many other models, especially those that do not have anything to do with the visual system.\n", "\n", "We now can ad other cell-types to our model, including inhibitory PV (parvalbumin) cells, with more calls to __add_nodes__:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "v1.add_nodes(\n", " # Rorb excitatory cells\n", " N=80, pop_name='Rorb', location='L4', ei='e',\n", " model_type='biophysical',\n", " model_template='ctdb:Biophys1.hoc',\n", " dynamics_params='473863510_fit.json',\n", " morphology='Rorb_325404214_m.swc',\n", " model_processing='aibs_perisomatic',\n", " x=np.random.normal(0.0, 20.0, size=80),\n", " y=np.random.uniform(400.0, 500.0, size=80),\n", " z=np.random.normal(0.0, 20.0, size=80), \n", " rotation_angle_xaxis=np.random.uniform(0.0, 2*np.pi, size=80),\n", " rotation_angle_yaxis=np.random.uniform(0.0, 2*np.pi, size=80),\n", " rotation_angle_zaxis=-4.159763785,\n", " tuning_angle=np.linspace(start=0.0, stop=360.0, num=80, endpoint=False),\n", ")\n", "\n", "\n", "v1.add_nodes(\n", " # Nr5a1 excitatory cells\n", " N=80, pop_name='Nr5a1', location='L4', ei='e',\n", " model_type='biophysical',\n", " model_template='ctdb:Biophys1.hoc',\n", " dynamics_params='473863035_fit.json',\n", " morphology='Nr5a1_471087815_m.swc',\n", " model_processing='aibs_perisomatic',\n", " x=np.random.normal(0.0, 20.0, size=80),\n", " y=np.random.uniform(400.0, 500.0, size=80),\n", " z=np.random.normal(0.0, 20.0, size=80), \n", " rotation_angle_xaxis=np.random.uniform(0.0, 2*np.pi, size=80),\n", " rotation_angle_yaxis=np.random.uniform(0.0, 2*np.pi, size=80),\n", " rotation_angle_zaxis=-4.159763785,\n", " tuning_angle=np.linspace(start=0.0, stop=360.0, num=80, endpoint=False),\n", ")\n", "\n", "v1.add_nodes(\n", " # Parvalbuim inhibitory cells, note these don't have a tuning angle and ei=i\n", " N=60, pop_name='PV1', location='L4', ei='i',\n", " model_type='biophysical',\n", " model_template='ctdb:Biophys1.hoc',\n", " dynamics_params='472912177_fit.json',\n", " morphology='Pvalb_470522102_m.swc',\n", " model_processing='aibs_perisomatic',\n", " x=np.random.normal(0.0, 20.0, size=60),\n", " y=np.random.uniform(400.0, 500.0, size=60),\n", " z=np.random.normal(0.0, 20.0, size=60), \n", " rotation_angle_xaxis=np.random.uniform(0.0, 2*np.pi, size=60),\n", " rotation_angle_yaxis=np.random.uniform(0.0, 2*np.pi, size=60),\n", " rotation_angle_zaxis=-2.539551891\n", ")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Creating the connections \n", "<img src=\"_static/images/builder_add_edges.png\" style=\"width: 350px; float: left\"/>\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we have our cells/nodes, we can go ahead and create the synapse/connectivity matrix using the __add_edges__ method. We will want to call this method multiple times to add different connection types with different properties and rules. For each connection type we must select what subpopulation of cells to use for the source (pre-synaptic) and target (post-synaptic) cells. We can select our cells using any combination of attributes" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "<bmtk.builder.connection_map.ConnectionMap at 0x7fee6d903c88>" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "v1.add_edges(\n", " ## Exc --> Inh type connections.\n", " source={'ei': 'e'}, \n", " target={'ei': 'i'},\n", " \n", " # Each source (ei='e') cell will connect once to every target (e) cell\n", " connection_rule=1,\n", " \n", " # SONATA keywords\n", " syn_weight=0.0006,\n", " delay=2.0,\n", " dynamics_params='ExcToInh.json',\n", " model_template='exp2syn',\n", " \n", " # Special BMTK attributes specifying where to set target synape location\n", " target_sections=['somatic', 'basal'],\n", " distance_range=[0.0, 1.0e+20]\n", ")\n", "\n", "v1.add_edges(\n", " ## Inh --> Exc type connections.\n", " source={'ei': 'i'}, \n", " target={'ei': 'e'},\n", " \n", " connection_rule=1,\n", " \n", " syn_weight=0.0002,\n", " delay=2.0,\n", " dynamics_params='InhToExc.json',\n", " model_template='exp2syn', \n", " target_sections=['somatic', 'basal', 'apical'],\n", " distance_range=[0.0, 50.0]\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The __connection_rule__ parameter is used to determine the number of connections/synapses between each source and target cell. In the simplist case like above we can pass in a scalar value. You may also pass in a matrix of shape T x S (T=# or targets, S=# of sources), or use in a custom function.\n", "\n", "With a user defined function it will pass in a source and target, which can be used as dictionaries to access cell parameters, and expects to return the number of connections\n", "```python\n", "def <my_connection_rule>(source, target, **opt_params):\n", " return N\n", "```\n", "\n", "For example for Inh --> Inh connection we want there to be no connections if the cells have the same id, otherwise randomly select the number of synapses" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "<bmtk.builder.connection_map.ConnectionMap at 0x7fee6d903be0>" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def ignore_autapses(source, target):\n", " # No synapses if source == target, otherwise randomize\n", " if source['node_id'] == target['node_id']:\n", " return 0\n", " else:\n", " return np.random.randint(1, 5)\n", "\n", "v1.add_edges(\n", " ## Inh --> Inh type connections.\n", " source={'ei': 'i'}, \n", " target={'ei': 'i'},\n", " \n", " connection_rule=ignore_autapses,\n", " \n", " syn_weight=0.00015,\n", " delay=2.0,\n", " dynamics_params='InhToInh.json',\n", " model_template='exp2syn',\n", " target_sections=['somatic', 'basal'],\n", " distance_range=[0.0, 1.0e+20]\n", ")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For Exc --> Exc we want to implement the connection patterns in which cells with more similar __tuning_angle__ are more likely to be connected with each other:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "<bmtk.builder.connection_map.ConnectionMap at 0x7fee6d90e0f0>" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def tuning_angle(source, target, max_syns):\n", " # ignore autoapses\n", " if source['node_id'] == target['node_id']:\n", " return 0\n", " \n", " # num of synapses is higher the closer the tuning_angles\n", " src_tuning = source['tuning_angle']\n", " trg_tuning = target['tuning_angle']\n", " dist = np.abs((src_tuning - trg_tuning + 180) % 360 - 180)\n", " p_dist = 1.0 - (np.max((dist, 10.0)) / 180.0)\n", " return np.random.binomial(n=max_syns, p=p_dist)\n", "\n", "v1.add_edges(\n", " source={'ei': 'e'}, \n", " target={'ei': 'e'},\n", " \n", " connection_rule=tuning_angle,\n", " connection_params={'max_syns': 5}, # pass in options to tuning_angle function\n", " \n", " syn_weight=3.0e-05,\n", " delay=2.0,\n", " dynamics_params='ExcToExc.json',\n", " model_template='exp2syn',\n", " target_sections=['basal', 'apical'],\n", " distance_range=[30.0, 150.0],\n", " \n", " # Will allow us to use our own custom functions to set syn_weight during simulation\n", " weight_function='set_syn_weight'\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Other connection parameters, particularly __syn_weight__ and __delay__, are scalar values and will be the same for each connection. There are multiple ways to set such values so it is customized for each connection. We will show one way of doing so later during the simulation stage, using the special BMTK __weight_function__ keyword." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Building the network\n", "<img src=\"_static/images/builder_complete_network.png\" style=\"width: 300px; float: left\"/>" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally we want to build our network and save the network files in SONATA format into the _network/_ directory. BMTK will intuit the names of the files." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "v1.build()\n", "v1.save(output_dir='network')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### External Network\n", "\n", "BMTK and SONATA gives modelers the options to build different parts of a network piecewise. For example we may want to build models of thalamacortical and higher cortical areas that we can connect to our V1 model.\n", "\n", "Next we create a separate network of the LGN, an flat area of the Thalamus with exciatory cells that project onto the V1. As before we define our cells, connect them to the v1 network, then build and save them as SONATA files in the _network/_ directory." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "lgn = NetworkBuilder('LGN') # Initialize network called 'lgn'\n", "\n", "lgn.add_nodes(\n", " N=50, \n", " model_type='virtual',\n", " model_template='lgnmodel:sOFF_TF8',\n", " dynamics_params='sOFF_TF8.json',\n", " \n", " # Special keyword used to determine the location and size of unit in \n", " # the receptive field\n", " x=np.random.uniform(0.0, 240.0, 50),\n", " y=np.random.uniform(0.0, 120.0, 50),\n", " spatial_size=1.0\n", ")\n", "\n", "lgn.add_nodes(\n", " N=50, \n", " model_type='virtual',\n", " model_template='lgnmodel:sON_TF8',\n", " dynamics_params='sON_TF8.json',\n", " x=np.random.uniform(0.0, 240.0, 50),\n", " y=np.random.uniform(0.0, 120.0, 50),\n", " spatial_size=1.0\n", ")\n", "\n", "lgn.add_edges(\n", " source=lgn.nodes(), # Select all LGN cells as the sources\n", " target=v1.nodes(ei='e'), # select V1 exc cells are the target\n", " \n", " connection_rule=lambda *_: np.random.randint(0, 5),\n", " syn_weight=0.0003,\n", " delay=2.0,\n", " dynamics_params='LGN_ExcToExc.json',\n", " model_template='exp2syn',\n", " target_sections=['basal', 'apical', 'somatic'],\n", " distance_range=[0.0, 50.0]\n", ")\n", "\n", "lgn.add_edges(\n", " source=lgn.nodes(), # Select all LGN cells as the sources\n", " target=v1.nodes(ei='i'), # select V1 exc cells are the target\n", " \n", " connection_rule=lambda *_: np.random.randint(0, 5),\n", " syn_weight=0.002,\n", " delay=2.0, \n", " dynamics_params='LGN_ExcToInh.json',\n", " model_template='exp2syn',\n", " target_sections=['basal', 'apical'],\n", " distance_range=[0.0, 1e+20]\n", ")\n", "\n", "lgn.build()\n", "lgn.save(output_dir='network')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Unlike the V1 cells, the LGN cells are __model_type=virtual__. In SONATA _virtual_ cells are special type of cell models that can't be recorded from, but can be used to synapse onto and stimulate other cells. There are essentially place-holders for spike trains (that will be set during the simulation).\n", "\n", "we have given the lgn special dynamics_params and model_template values, however these won't be used during the V1 simulation. There parameter values are used by FilterNet module." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simulating the Network\n", "\n", "\n", "<img src=\"_static/images/bmtk_workflow_simulator.png\" style=\"width: 700px; float: left\"/>" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we have built the SONATA network models files (or recieved the files from another source), we can go ahead and setup a simulation to run. To simulate the multi-compartment cell models we will use the BioNet component of the BMTK - which uses the [NEURON](https://www.neuron.yale.edu/neuron/) simulator libraries for simulating our network. \n", "\n", "Before we can do that there are still a few things that need to be taken care of, including setting up run-time parameters, choosing the stimulus, and deciding what to record." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Simulation Directory Structure\n", "\n", "Almost all of the parameters required to initialize and run a full V1 simulation will be stored in a [SONATA base json configuration file](https://github.com/AllenInstitute/sonata/blob/master/docs/SONATA_DEVELOPER_GUIDE.md#tying-it-all-together---the-networkcircuit-config-file), in this case named _config.bionet.json_. If you need to (re)create the file the following command will create a template:\n", "\n", "```python\n", " python -m bmtk.utils.sim_setup \\\n", " --network network \\\n", " --dt 0.1 \\\n", " --tstop 2000.0 \\ \n", " --compile-mechanisms \\\n", " --include-examples \\\n", " --config=config.bionet.json \\\n", " bionet .\n", "```\n", "\n", "Opening up the json with a text editor we can see the configuration is divided into different sections\n", "\n", "\n", "#### \"networks\"\n", "\n", "This section contains paths to the sonata network files we built above. We can use this to add or remove node populations and edges before running another simulation.\n", "\n", "\n", "#### \"components\"\n", "\n", "Contains the paths to the different external files and parameters required to run a simulation; morphologies, electricophysicological parameters (eg. NeuroML files), synaptic model parameters, etc. Files that are not directly defined as a part of the SONATA files but used by specific simulator software (eg NEURON, NEST).\n", "\n", "The required files for this tutorial has already be created. In other cases one would likely have to spend a signficant amount of time creating the optimized parameter files.\n", "\n", "\n", "#### \"run\"\n", "\n", "Run-time parameters and conditions, including simulation time and the time-step (all time values are in miliseconds).\n", "\n", "\n", "#### \"output\"\n", "\n", "Paths and parameters used for simulation output and logging.\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### \"reports\"\n", "\n", "By default BMTK will record the V1 cell spikes into a file specified under **outputs/spikes_file**. For these types of models we can also record other parameters like membrane potential, calcium concentration, or extracellular electrical fields by adding to the \"reports\" section of the configuration file. \n", "\n", "For example the following can be used to record the soma membrane potential traces for our Scnn1a cells and save them in *output/membrane_potential.h5*\n", "\n", "```json\n", " \"membrane_potential\": {\n", " \"cells\": {\n", " \"population\": \"V1\", \n", " \"pop_name\": \"Scnn1a\"\n", " },\n", " \"variable_name\": \"v\",\n", " \"module\": \"membrane_report\",\n", " \"sections\": \"soma\"\n", " }\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### \"inputs\"\n", "\n", "This section can be used to specify one or more stimulus we want to use on our V1 model. Depending on the type of cell models being used, we can use spike trains, current clamps, voltage clamps, or extracellular electrodes. \n", "\n", "For our V1 network we created a population of LGN \"virtual\" cells that synapse onto our V1 cells and drive them with spike trains. All that is missing is a \"spike-trains\" file, which can be either a CSV, NWB, or SONATA HDF5 file. BMTK includes way to create spike-train files.\n", "\n", "The following will create a series of spike trains for the LGN cells using a Poisson distribution with a mean firing rate of 8 Hz:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "from bmtk.utils.reports.spike_trains import PoissonSpikeGenerator\n", "\n", "psg = PoissonSpikeGenerator(population='LGN')\n", "psg.add(\n", " node_ids=range(0, 100),\n", " firing_rate=8.0, # We can also pass in a nonhomoegenous function/array\n", " times=(0.0, 2.0) # Firing starts at 0 s up to 2 seconds\n", ")\n", "\n", "psg.to_sonata('inputs/lgn_spikes.poisson.h5')\n", "psg.to_csv('inputs/lgn_spikes.poisson.csv')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "and update the \"inputs\" section \n", "\n", "```json\n", " \"LGN_spikes\": {\n", " \"input_type\": \"spikes\",\n", " \"module\": \"h5\",\n", " \"input_file\": \"./inputs/lgn_spikes.poisson.h5\",\n", " \"node_set\": \"LGN\"\n", " }\n", "```\n", "\n", "BMTK also includes a tool FilterNet that allows us to turn movies and images into firing rates using optimized filter models, which we will do in future sections." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Running the simulation\n", "\n", "Now that we have our configuration files as we need, we can go ahead and run a simulation. We can execute the *run_bionet.py* script using the command line option:\n", "\n", "```bash\n", " $ python run_bionet.py config.bionet.json\n", "```\n", "\n", "Although this toy network is small enough to run most modern computers and laptops, for larger networks we may need to run the program on a cluster with \\<N\\> cores. To do so \n", "\n", "```bash\n", " $ mpirun -np <N> nrniv -mpi -python run_bionet.py config.bionet.json\n", "```\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2021-06-24 11:23:10,647 [INFO] Created log file\n", "2021-06-24 11:23:10,780 [INFO] Building cells.\n", "2021-06-24 11:23:35,286 [INFO] Building recurrent connections\n", "2021-06-24 11:25:53,734 [INFO] Building virtual cell stimulations for LGN_spikes\n", "2021-06-24 11:26:18,614 [INFO] Running simulation for 2000.000 ms with the time step 0.100 ms\n", "2021-06-24 11:26:18,615 [INFO] Starting timestep: 0 at t_sim: 0.000 ms\n", "2021-06-24 11:26:18,616 [INFO] Block save every 5000 steps\n", "2021-06-24 11:27:47,544 [INFO] step:5000 t_sim:500.00 ms\n", "2021-06-24 11:29:18,175 [INFO] step:10000 t_sim:1000.00 ms\n", "2021-06-24 11:30:49,458 [INFO] step:15000 t_sim:1500.00 ms\n", "2021-06-24 11:32:21,530 [INFO] step:20000 t_sim:2000.00 ms\n", "2021-06-24 11:32:21,593 [INFO] Simulation completed in 6.0 minutes, 2.979 seconds \n" ] } ], "source": [ "from bmtk.simulator import bionet\n", "\n", "conf = bionet.Config.from_json('config.bionet.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": [ "As specified in the \"output\" and \"reports\" section, the results of the simulation will be saved in different files in the _output_ directory. The spike-trains files, *spikes.h5*, and membrane potentials, *membrane_potential.h5* are [SONATA output data formatted file](https://github.com/AllenInstitute/sonata/blob/master/docs/SONATA_DEVELOPER_GUIDE.md#output-file-formats) and can be read and analyized by any tools that can read SONATA. \n", "\n", "Using BMTK to display the results:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "<Figure size 432x288 with 2 Axes>" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from bmtk.analyzer.spike_trains import plot_raster\n", "\n", "# Plot the spike trains raster\n", "_ = plot_raster(config_file='config.bionet.json', group_by='pop_name')" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "<Figure size 432x288 with 1 Axes>" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from bmtk.analyzer.compartment import plot_traces\n", "\n", "# Plot the membrane potential trace, the blue represents the mean trace of all cells (in grey)\n", "_ = plot_traces(config_file='config.bionet.json', group_by='pop_name', report_name='membrane_potential')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Cell perturbations\n", "\n", "A usefull tool in network neuroscience is the ability to stimulate or supress a one or more neurons in a network, either using optogenetic tools or current clamps. To simulate this effect in BMTK we can use a current clamp on multiple neurons by adding the following to the \"inputs\" section of the configuration file:\n", "\n", "\n", "```json\n", " \"inputs\": { \n", " \"inh_perturbation\": {\n", " \"input_type\": \"current_clamp\",\n", " \"module\": \"IClamp\",\n", " \"node_set\": {\n", " \"population\": \"V1\",\n", " \"pop_name\": \"Nr5a1\", \n", " \"location\": \"L4\"\n", " },\n", " \"amp\": -1.0,\n", " \"delay\": 500.0,\n", " \"duration\": 1500.0\n", " }\n", " }\n", "```\n" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# Will reset BioNet and the NEURON simulator. Required if we want\n", "# to run the simulator multiple times in the same notebook.\n", "bionet.reset()" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2021-06-24 11:33:07,574 [INFO] Created log file\n", "Mechanisms already loaded from path: ./components/mechanisms. Aborting.\n", "2021-06-24 11:33:07,675 [INFO] Building cells.\n", "2021-06-24 11:34:58,720 [INFO] Building recurrent connections\n", "2021-06-24 11:37:23,018 [INFO] Building virtual cell stimulations for LGN_spikes\n", "2021-06-24 11:37:49,440 [INFO] Running simulation for 2000.000 ms with the time step 0.100 ms\n", "2021-06-24 11:37:49,441 [INFO] Starting timestep: 0 at t_sim: 0.000 ms\n", "2021-06-24 11:37:49,442 [INFO] Block save every 5000 steps\n", "2021-06-24 11:40:57,854 [INFO] step:5000 t_sim:500.00 ms\n", "2021-06-24 11:44:23,932 [INFO] step:10000 t_sim:1000.00 ms\n", "2021-06-24 11:47:32,163 [INFO] step:15000 t_sim:1500.00 ms\n", "2021-06-24 11:50:43,726 [INFO] step:20000 t_sim:2000.00 ms\n", "2021-06-24 11:50:43,783 [INFO] Simulation completed in 12.0 minutes, 54.34 seconds \n" ] } ], "source": [ "conf = bionet.Config.from_json('config.bionet.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": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "<Figure size 432x288 with 2 Axes>" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "_ = plot_raster(config_file='config.bionet.json', group_by='pop_name')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Recording extracellular potential (ECP)\n", "\n", "The configuration has been set-up to record spike-trains and the membrane potentials of a subset of cells. BioNet also includes the ability to record the extracelluar potential using a simulated electrode, which will allow us to find the ECP and even the local field potential.\n", "\n", "First we must add the following to the \"inputs\" section\n", "\n", "```json\n", "\"reports\": {\n", " \"ecp\": {\n", " \"module\": \"extracellular\",\n", " \"variable_name\": \"v\",\n", " \"cells\": {\n", " \"population\": \"V1\",\n", " \"model_type\": \"biophysical\"\n", " },\n", " \"electrode_positions\": \"./components/devices/linear_electrode.csv\",\n", " \"file_name\": \"ecp.h5\",\n", " \"electrode_channels\": \"all\"\n", " }\n", "}\n", "```\n", "\n", "The *devices/linear_electrode.csv* file is what we use to specify the electrode and all the recording channels. for this simulation the electrode will be placed through the center of the V1 column with recording channels at every 100 microns (the **x**, **y**, **z** coordinates of the electrode should be in the same space as the cells).\n", "\n", "<img src=\"_static/images/v1_neuropixel_probe.png\" style=\"width: 350px; float: left\"/> <!-- style=\"width: 5px; float: left\"/> -->\n", "\n", "| channel | x_pos | y_pos | z_pos |\n", "| :--- | :--- | :--- | :--- |\n", "|0 | 0.0 | 0 | 0.0 |\n", "|1 | 0.0 | 100 | 0.0 |\n", "|2 | 0.0 | 200 | 0.0 |\n", "|3 | 0.0 | 300 | 0.0 |\n", "|4 | 0.0 | 400 | 0.0 |\n", "|5 | 0.0 | 500 | 0.0 |\n", "|6 | 0.0 | 600 | 0.0 |\n", "|7 | 0.0 | 700 | 0.0 |\n", "|8 | 0.0 | 800 | 0.0 |\n", "|9 | 0.0 | 900 | 0.0\n", "\n", "\n", "\n", "Now we can run the simulation as before:\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# Will reset BioNet and the NEURON simulator. Required if we want\n", "# to run the simulator multiple times in the same notebook.\n", "bionet.reset()" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2021-06-24 12:04:20,572 [INFO] Created log file\n", "2021-06-24 12:04:20,722 [INFO] Building cells.\n", "2021-06-24 12:04:49,375 [INFO] Building recurrent connections\n", "2021-06-24 12:07:39,111 [INFO] Building virtual cell stimulations for LGN_spikes\n", "2021-06-24 12:08:06,819 [INFO] Running simulation for 2000.000 ms with the time step 0.100 ms\n", "2021-06-24 12:08:06,820 [INFO] Starting timestep: 0 at t_sim: 0.000 ms\n", "2021-06-24 12:08:06,820 [INFO] Block save every 5000 steps\n", "2021-06-24 12:26:10,664 [INFO] step:5000 t_sim:500.00 ms\n", "2021-06-24 12:43:55,769 [INFO] step:10000 t_sim:1000.00 ms\n", "2021-06-24 13:01:19,182 [INFO] step:15000 t_sim:1500.00 ms\n", "2021-06-24 13:19:58,561 [INFO] step:20000 t_sim:2000.00 ms\n", "2021-06-24 13:19:58,629 [INFO] Simulation completed in 71.0 minutes, 51.81 seconds \n" ] } ], "source": [ "conf = bionet.Config.from_json('config.bionet.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": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "<Figure size 432x288 with 10 Axes>" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from bmtk.analyzer.ecp import plot_ecp\n", "\n", "_ = plot_ecp(config_file='config.bionet.json', report_name='ecp')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Adjusting the synaptic weights\n", "\n", "Currently the synaptic weights, eg __syn_weight__ property, are set to the same value for each edge-type. There are multiple ways to make it so the synaptic weights are nonhomogenous. We can calculate and store nonhomogenous synaptic weights inside the SONATA edges files. Or we can adjust the weights before each simulation - which is a bit less efficent but will give us greater flexiblity as we try to optimize the weights.\n", "\n", "for Exc --> Exc edges we had a BMTK special keyword __weight_function__='set_syn_weight', which allows us to create user-defined functions to adjust the synaptic weights during the initialization of the simulation. BMTK will look for a function with signature \n", "```python\n", "def <function_name>(edge_props, source, target)\n", "```\n", "\n", "Where **edge_props**, **source**, **target** are dictionary-like objects that can be used to fetch edges-properties, source cell properties, and target-cell properties.\n", "\n", "For our function we want to rewrite it so the __syn_weight__ value is readjusted based on the distance.\n", "\n" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "# Will reset BioNet and the NEURON simulator. Required if we want\n", "# to run the simulator multiple times in the same notebook.\n", "bionet.reset()" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "2021-06-24 14:04:25,042 [INFO] Created log file \n", "2021-06-24 14:04:25,147 [INFO] Building cells.\n", "2021-06-24 14:04:49,026 [INFO] Building recurrent connections\n", "2021-06-24 14:07:13,852 [INFO] Building virtual cell stimulations for LGN_spikes\n", "2021-06-24 14:07:38,980 [INFO] Running simulation for 2000.000 ms with the time step 0.100 ms\n", "2021-06-24 14:07:38,980 [INFO] Starting timestep: 0 at t_sim: 0.000 ms\n", "2021-06-24 14:07:38,980 [INFO] Block save every 5000 steps\n", "2021-06-24 14:09:05,559 [INFO] step:5000 t_sim:500.00 ms\n", "2021-06-24 14:10:31,855 [INFO] step:10000 t_sim:1000.00 ms\n", "2021-06-24 14:11:59,001 [INFO] step:15000 t_sim:1500.00 ms\n", "2021-06-24 14:13:24,835 [INFO] step:20000 t_sim:2000.00 ms\n", "2021-06-24 14:13:24,894 [INFO] Simulation completed in 5.0 minutes, 45.91 seconds \n", "\n" ] } ], "source": [ "def set_syn_weight(edge_props, source, target):\n", " # fetch base-line syn_weight value stored in edge_types properties\n", " syn_weight = edge_props[\"syn_weight\"]\n", " \n", " # get the coords for the pre/post-synaptic cell and calculate distance\n", " src_coords = np.array([source['x'], source['y'], source['z']])\n", " trg_coords = np.array([target['x'], target['y'], target['z']])\n", " dist = np.linalg.norm(src_coords - trg_coords)\n", " \n", " if dist > 60: \n", " return syn_weight\n", " else:\n", " return syn_weight*(-0.165*dist + 10.0)\n", "\n", "\n", "# This will register our function so BMTK can find it\n", "bionet.add_weight_function(set_syn_weight)\n", " \n", "conf = bionet.Config.from_json('config.bionet.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": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "<Figure size 432x288 with 2 Axes>" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from bmtk.analyzer.spike_trains import plot_raster\n", "\n", "_ = plot_raster(config_file='config.bionet.json', group_by='pop_name')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Generating realistic stimulus\n", "\n", "To drive our network model we have been using external \"LGN\" virtual cells that fire at a constant rate. This can be useful for testing some fundamental properties of the network. However to better optimize our model it will be useful to simulate it against more realistic stimulus.\n", "\n", "FilterNet is a component of the BMTK that allows us to project an image or movie onto one or more neurons to produce spike trains. Using FilterNet with the \"LGN\" network we can create spike-train files using various types of visual stimulus, which can then be used as input for simulating the V1 model.\n", "\n", "<img src=\"_static/images/filternet_lnp.png\" alt=\"Drawing\" style=\"width: 700px; float: left\"/>" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### FilterNet Directory Structure\n", "\n", "FilterNet simulation directory is structured the same as BioNet, using a json configuration file to specify the paths and parameters required to run a full simulation. The configuration and model files are already set-up, but when building a simulation from scratch one can create directory template using the command line tool:\n", "\n", "```bash\n", " $ python -m bmtk.utils.sim_setup \\\n", " --network network \\\n", " --tstop 2000.0 \\ \n", " --include-examples \\\n", " --config=config.filternet.json \\\n", " filternet .\n", "```\n", "\n", "Controlling the FilterNet simulation is done through *config.filternet.json*, which has the same format used by _config.bionet.json_, except with some noticeable changes.\n", "\n", "#### \"networks\"\n", "\n", "We only want to run FilterNet against the LGN nodes (and FilterNet currently doesn't support recurrent networks), which is reflected by the \"network\" sections in the configuration:\n", "\n", "```json\n", " \"networks\": {\n", " \"nodes\": [\n", " {\n", " \"nodes_file\": \"$NETWORK_DIR/LGN_nodes.h5\",\n", " \"node_types_file\": \"$NETWORK_DIR/LGN_node_types.csv\"\n", " }\n", " ]\n", " }\n", "```\n", "\n", "#### \"output\"\n", "Like in BioNet, FilterNet will produce a SONATA formated spike-trains file, but for our \"LGN\" nodes only. The location of the output is controlled by the \"output\" section of the configuration file:\n", "\n", "``` json\n", " \"output\": { \n", " \"log_file\": \"log.txt\",\n", " \"output_dir\": \"./inputs\",\n", " \"spikes_file\": \"lgn_spikes.flash.h5\"\n", " },\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### \"inputs\"\n", "\n", "The \"inputs\" section of the configuration file determines which type of stimulus we want to project onto LGN cells. Although we can use any user-created movie (described below), FilterNet also comes with options for easily creating special stimulus types that are common in experiments testing the visual system.\n", "\n", "One of the simplest types of stimuli is a full-field flash, a temporary bright (or dark) flash on the receptive field, which can be used to test simple ON/OFF cells found in the LGN. The following will create a bright flash between 500 and 1500 ms seconds\n", "\n", "```json\n", " \"inputs\": {\n", " \"full_field_flash\": {\n", " \"input_type\": \"movie\",\n", " \"module\": \"full_field_flash\",\n", " \"row_size\": 120,\n", " \"col_size\": 240,\n", " \"t_on\": 500.0,\n", " \"t_off\": 1500.0,\n", " \"max_intensity\": 1.0,\n", " \"frame_rate\": 1000.0\n", " } \n", " }\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Running the Simulation\n", "\n", "Now that we have our configuration file setup we can run filternet. In the command line this can be done by:\n", " \n", "```bash\n", " $ python run_filternet.py config.filernet.json\n", "```\n", "\n", "For every large networks that would require multiple processors to complete in a reasonable amount of time we can use the command\n", "```bash\n", " $ mpirun -n <N> python run_filternet.py config.filernet.json\n", "```\n", "\n", "Or through the following code:\n" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2021-06-24 14:16:06,482 [WARNING] Directory ./inputs already exists.\n", "2021-06-24 14:16:06,483 [INFO] Created log file\n", "2021-06-24 14:16:07,970 [INFO] Building cells.\n", "2021-06-24 14:16:11,337 [INFO] Evaluating rates.\n", "2021-06-24 14:16:33,327 [INFO] Done.\n" ] } ], "source": [ "from bmtk.simulator import filternet\n", "\n", "config = filternet.Config.from_json('config.filternet.json')\n", "config.build_env()\n", "net = filternet.FilterNetwork.from_config(config)\n", "sim = filternet.FilterSimulator.from_config(config, net)\n", "sim.run()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Once completed it will create the spikes-file lgn_results/lgn_spikes.flash.h5. This file follows the same format as the spike-trains file generated by BioNet. To see how our LGN ON/OFF cells responded to the full-field flash:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "<Figure size 432x288 with 2 Axes>" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from bmtk.analyzer.spike_trains import plot_raster\n", "\n", "_ = plot_raster(config_file='config.filternet.json', group_by='model_template')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Using the results for the V1 model\n", "\n", "To use the results to test our V1 model with more realistic stimulus, we just need to open _config.bionet.json_ and edit the \"inputs\" section so the __input_file__ is changed from *./inputs/lgn_spikes.h5* to *./lgn_results/lgn_spikes.flash.h5*\n", "\n", "```json\n", " \"inputs\": { \n", " \"LGN_spikes\": {\n", " \"input_type\": \"spikes\",\n", " \"module\": \"h5\",\n", " \"input_file\": \"./inputs/spikes.flash.h5\",\n", " \"node_set\": \"LGN\"\n", " }\n", " }\n", "```\n", "\n", "Then just rereun the BioNet code as above and see what happens when we use the new stimulus." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "<Figure size 432x288 with 2 Axes>" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from bmtk.analyzer.spike_trains import plot_raster\n", "\n", "_ = plot_raster(config_file='config.bionet.flash.json', group_by='pop_name')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### More Stimulus Types\n", "\n", "Besides Full-Field Flashes, FilterNet also can generate other types of pre-set visual stimuli. However for more advanced stimuli one will have to create their own movies.\n", "\n", "To do so first you will need to create a [numpy npy or npz file](https://numpy.org/doc/stable/reference/generated/numpy.save.html) - eg a 3-dimensional array consisting of the frames x rows x columns of each pixel. FilterNet will gray-scale the images automatically. Once the movie has been saved, open up the FilerNet json configuration file and modify the \"inputs\" section accordingly (make sure frame_rate is correct).\n", "\n", "```json\n", " \"inputs\": {\n", " \"full_field_flash\": {\n", " \"input_type\": \"movie\",\n", " \"module\": \"movie\",\n", " \"data_file\": \"/path/to/my/movie.npy\",\n", " \"frame_rate\": 1000.0\n", " } \n", " }\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simulating across different levels of resolutions\n", "\n", "So far we've been running a simulation using multi-compartment models of cells using the BioNet component of the BMTK. Often in modeling we want to test different types of models, for both computational and scientific reasons. \n", "\n", "### Point-neuron models\n", "With PointNet, we can run our network using point-neuron based models using the [NEST](https://www.nest-simulator.org/) simulator libraries. PointNet will also use the same SONATA network files and configuration format for describing a network and initializing a simulation, so we can compare the same network across different levels of resolution. However certain properties, like __syn_weight__, __model_template__, and __dynamics_params__ will need to be adjusted. For more information see the [PointNet tutorial](https://alleninstitute.github.io/bmtk/tutorials/tutorial_05_pointnet_modeling.html).\n", "\n", "\n", "### Population based firing rate models\n", "With PopNet we can simulate the different cell-types as singular populations using the [DipDE](http://alleninstitute.github.io/dipde/) simulator. Just like BioNet and PointNet it utilizes the SONATA formats. However instead of recording spike-trains for individual cells, PopNet will record the firing-rate dynamics over the course of the simulation. For more information see the [PopNet tutorial](https://alleninstitute.github.io/bmtk/tutorials/tutorial_06_population_modeling.html)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Additional Resources\n", "\n", "https://alleninstitute.github.io/bmtk\n", "\n", "\n", "https://github.com/AllenInstitute/bmtk/tree/develop/docs/tutorial/modeling_tut_2021\n", "\n", "\n", "### Additional Tutorials\n", "\n", "* **Network Builder** - https://alleninstitute.github.io/bmtk/tutorial_NetworkBuilder_Intro.html\n", "\n", "* **BioNet** - https://alleninstitute.github.io/bmtk/tutorial_single_pop.html\n", "\n", "* **FilterNet** - https://alleninstitute.github.io/bmtk/tutorial_filter_models.html\n", "\n", "* **PointNet** - https://alleninstitute.github.io/bmtk/tutorial_pointnet_modeling.html\n", "\n", "* **PopNet** - https://alleninstitute.github.io/bmtk/tutorial_population_modeling.html\n", "\n", "\n", "### Examples\n", "\n", "* https://github.com/AllenInstitute/bmtk/tree/develop/examples\n", "\n", "\n", "\n", "### Mouse Layer 4 Model\n", "\n", "* http://portal.brain-map.org/explore/models/l4-mv1\n", "\n", "\n", "### Mouse Full V1 Model\n", "\n", "* http://portal.brain-map.org/explore/models/mv1-all-layers" ] }, { "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.16" } }, "nbformat": 4, "nbformat_minor": 4 }