 |
GeNN
2.2.3
GPU enhanced Neuronal Networks (GeNN)
|
|
GeNN
2.2.3
GPU enhanced Neuronal Networks (GeNN)
|
GeNN comes with a number of complete examples. At the moment, there are seven such example projects provided with GeNN.
Izhikevich neuron(s) without any connections ===================================== This is a minimal example, with only one neuron population (with more or less neurons depending on the command line, but without any synapses). The neurons are Izhikevich neurons with homogeneous parameters across the neuron population. This example project contains a helper executable called "generate_run", which also prepares additional synapse connectivity and input pattern data, before compiling and executing the model. To compile it, navigate to genn/userproject/OneComp_project and type: nmake /f WINmakefile for Windows users, or: make for Linux, Mac and other UNIX users. USAGE ----- generate_run <0(CPU)/1(GPU)> <n> <DIR> <MODEL> Optional arguments: DEBUG=0 or DEBUG=1 (default 0): Whether to run in a debugger FTYPE=DOUBLE of FTYPE=FLOAT (default FLOAT): What floating point type to use REUSE=0 or REUSE=1 (default 0): Whether to reuse generated connectivity from an earlier run CPU_ONLY=0 or CPU_ONLY=1 (default 0): Whether to compile in (CUDA independent) "CPU only" mode. For a first minimal test, the system may be used with: generate_run.exe 1 1 outdir OneComp for Windows users, or: ./generate_run 1 1 outdir OneComp for Linux, Mac and other UNIX users. This would create a set of tonic spiking Izhikevich neurons with no connectivity, receiving a constant identical 4 nA input. It is lso possible to use the model with a sinusoidal input instead, by setting the input to INPRULE. Another example of an invocation would be: generate_run.exe 0 1 outdir OneComp FTYPE=DOUBLE CPU_ONLY=1 for Windows users, or: ./generate_run 0 1 outdir OneComp FTYPE=DOUBLE CPU_ONLY=1 for Linux, Mac and other UNIX users.
Izhikevich neuron model: [1]
Izhikevich network receiving Poisson input spike trains ======================================================= In this example project there is again a pool of non-connected Izhikevich model neurons that are connected to a pool of Poisson input neurons with a fixed probability. This example project contains a helper executable called "generate_run", which also prepares additional synapse connectivity and input pattern data, before compiling and executing the model. To compile it, navigate to genn/userproject/PoissonIzh_project and type: nmake /f WINmakefile for Windows users, or: make for Linux, Mac and other UNIX users. USAGE ----- generate_run <0(CPU)/1(GPU)> <nPoisson> <nIzhikevich> <pConn> <gscale> <DIR> <MODEL> Optional arguments: DEBUG=0 or DEBUG=1 (default 0): Whether to run in a debugger FTYPE=DOUBLE or FTYPE=FLOAT (default FLOAT): What floating point type to use REUSE=0 or REUSE=1 (default 0): Whether to reuse generated connectivity from an earlier run CPU_ONLY=0 or CPU_ONLY=1 (default 0): Whether to compile in (CUDA independent) "CPU only" mode. An example invocation of generate_run is: generate_run.exe 1 100 10 0.5 2 outdir PoissonIzh for Windows users, or: ./generate_run 1 100 10 0.5 2 outdir PoissonIzh for Linux, Mac and other UNIX users. This will generate a network of 100 Poisson neurons with 20 Hz firing rate connected to 10 Izhikevich neurons with a 0.5 probability. The same network with sparse connectivity can be used by adding the synapse population with sparse connectivity in PoissonIzh.cc and by uncommenting the lines following the "//SPARSE CONNECTIVITY" tag in PoissonIzh.cu and commenting the lines following `//DENSE CONNECTIVITY`. Another example of an invocation would be: generate_run.exe 0 100 10 0.5 2 outdir PoissonIzh FTYPE=DOUBLE CPU_ONLY=1 for Windows users, or: ./generate_run 0 100 10 0.5 2 outdir PoissonIzh FTYPE=DOUBLE CPU_ONLY=1 for Linux, Mac and other UNIX users.
Izhikevich neuron model: [1]
Pulse-coupled Izhikevich network ================================ This example model is inspired by simple thalamo-cortical network of Izhikevich with an excitatory and an inhibitory population of spiking neurons that are randomly connected. It creates a pulse-coupled network with 80% excitatory 20% inhibitory connections, each connecting to nConn neurons with sparse connectivity. To compile it, navigate to genn/userproject/Izh_sparse_project and type: nmake /f WINmakefile for Windows users, or: make for Linux, Mac and other UNIX users. USAGE ----- generate_run <0(CPU)/1(GPU)/n(GPU n-2)> <nNeurons> <nConn> <gScale> <outdir> <model name> <input factor> Mandatory arguments: CPU/GPU: Choose whether to run the simulation on CPU (`0`), auto GPU (`1`), or GPU (n-2) (`n`). nNeurons: Number of neurons nConn: Number of connections per neuron gScale: General scaling of synaptic conductances outname: The base name of the output location and output files model name: The name of the model to execute, as provided this would be `Izh_sparse` Optional arguments: DEBUG=0 or DEBUG=1 (default 0): Whether to run in a debugger FTYPE=DOUBLE of FTYPE=FLOAT (default FLOAT): What floating point type to use REUSE=0 or REUSE=1 (default 0): Whether to reuse generated connectivity from an earlier run CPU_ONLY=0 or CPU_ONLY=1 (default 0): Whether to compile in (CUDA independent) "CPU only" mode. An example invocation of generate_run is: generate_run.exe 1 10000 1000 1 outdir Izh_sparse 1.0 for Windows users, or: ./generate_run 1 10000 1000 1 outdir Izh_sparse 1.0 for Linux, Mac and other UNIX users. This would create a pulse coupled network of 8000 excitatory 2000 inhibitory Izhikevich neurons, each making 1000 connections with other neurons, generating a mixed alpha and gamma regime. For larger input factor, there is more input current and more irregular activity, for smaller factors less and less and more sparse activity. The synapses are of a simple pulse-coupling type. The results of the simulation are saved in the directory `outdir_output`, debugging is switched off, and the connectivity is generated afresh (rather than being read from existing files). If connectivity were to be read from files, the connectivity files would have to be in the `inputfiles` sub-directory and be named according to the names of the synapse populations involved, e.g., `gIzh_sparse_ee` (\<variable name>=`g` \<model name>=`Izh_sparse` \<synapse population>=`_ee`). These name conventions are not part of the core GeNN definitions and it is the privilege (or burden) of the user to find their own in their own versions of `generate_run`. Another example of an invocation would be: generate_run.exe 0 10000 1000 1 outdir Izh_sparse 1.0 FTYPE=DOUBLE DEBUG=0 CPU_ONLY=1 for Windows users, or: ./generate_run 0 10000 1000 1 outdir Izh_sparse 1.0 FTYPE=DOUBLE DEBUG=0 CPU_ONLY=1 for Linux, Mac and other UNIX users.
Izhikevich neuron model: [1]
Izhikevich network with delayed synapses ======================================== This example project demonstrates the synaptic delay feature of GeNN. It creates a network of three Izhikevich neuron groups, connected all-to-all with fast, medium and slow synapse groups. Neurons in the output group only spike if they are simultaneously innervated by the input neurons, via slow synapses, and the interneurons, via faster synapses. COMPILE (WINDOWS) ----------------- To run this example project, first build the model into CUDA code by typing: genn-buildmodel.bat SynDelay.cc then compile the project by typing: nmake /f WINmakefile COMPILE (MAC AND LINUX) ----------------------- To run this example project, first build the model into CUDA code by typing: genn-buildmodel.sh SynDelay.cc then compile the project by typing: make USAGE ----- syn_delay [CPU = 0 / GPU = 1] [directory to save output]
Izhikevich neuron model: [1]
Locust olfactory system (Nowotny et al. 2005) ============================================= This project implements the insect olfaction model by Nowotny et al. that demonstrates self-organized clustering of odours in a simulation of the insect antennal lobe and mushroom body. As provided the model works with conductance based Hodgkin-Huxley neurons and several different synapse types, conductance based (but pulse-coupled) excitatory synapses, graded inhibitory synapses and synapses with a simplified STDP rule. This example project contains a helper executable called "generate_run", which also prepares additional synapse connectivity and input pattern data, before compiling and executing the model. To compile it, navigate to genn/userproject/MBody1_project and type: nmake /f WINmakefile for Windows users, or: make for Linux, Mac and other UNIX users. USAGE ----- generate_run <0(CPU)/1(GPU)/n(GPU n-2)> <nAL> <nKC> <nLH> <nDN> <gScale> <DIR> <MODEL> Mandatory parameters: CPU/GPU: Choose whether to run the simulation on CPU (`0`), auto GPU (`1`), or GPU (n-2) (`n`). nAL: Number of neurons in the antennal lobe (AL), the input neurons to this model nKC: Number of Kenyon cells (KC) in the "hidden layer" nLH: Number of lateral horn interneurons, implementing gain control nDN: Number of decision neurons (DN) in the output layer gScale: A general rescaling factor for snaptic strength outname: The base name of the output location and output files model: The name of the model to execute, as provided this would be `MBody1` Optional arguments: DEBUG=0 or DEBUG=1 (default 0): Whether to run in a debugger FTYPE=DOUBLE of FTYPE=FLOAT (default FLOAT): What floating point type to use REUSE=0 or REUSE=1 (default 0): Whether to reuse generated connectivity from an earlier run CPU_ONLY=0 or CPU_ONLY=1 (default 0): Whether to compile in (CUDA independent) "CPU only" mode. An example invocation of generate_run is: generate_run.exe 1 100 1000 20 100 0.0025 outname MBody1 for Windows users, or: ./generate_run 1 100 1000 20 100 0.0025 outname MBody1 for Linux, Mac and other UNIX users. Such a command would generate a locust olfaction model with 100 antennal lobe neurons, 1000 mushroom body Kenyon cells, 20 lateral horn interneurons and 100 mushroom body output neurons, and launch a simulation of it on a CUDA-enabled GPU using single precision floating point numbers. All output files will be prefixed with "outname" and will be created under the "outname" directory. The model that is run is defined in `model/MBody1.cc`, debugging is switched off, the model would be simulated using float (single precision floating point) variables and parameters and the connectivity and input would be generated afresh for this run. In more details, what generate_run program does is: a) use some other tools to generate the appropriate connectivity matrices and store them in files. b) build the source code for the model by writing neuron numbers into ./model/sizes.h, and executing "genn-buildmodel.sh ./model/MBody1.cc. c) compile the generated code by invoking "make clean && make" running the code, e.g. "./classol_sim r1 1". Another example of an invocation would be: generate_run.exe 0 100 1000 20 100 0.0025 outname MBody1 FTYPE=DOUBLE CPU_ONLY=1 for Windows users, or: ./generate_run 0 100 1000 20 100 0.0025 outname MBody1 FTYPE=DOUBLE CPU_ONLY=1 for Linux, Mac and other UNIX users, for using double precision floating point and compiling and running the "CPU only" version. Note: Optional arguments cannot contain spaces, i.e. "CPU_ONLY= 0" will fail. As provided, the model outputs a file `test1.out.st` that contains the spiking activity observed in the simulation, There are two columns in this ASCII file, the first one containing the time of a spike and the second one the ID of the neuron that spiked. Users of matlab can use the scripts in the `matlab` directory to plot the results of a simulation. For more about the model itself and the scientific insights gained from it see Nowotny et al. referenced below. MODEL INFORMATION ----------------- For information regarding the locust olfaction model implemented in this example project, see: T. Nowotny, R. Huerta, H. D. I. Abarbanel, and M. I. Rabinovich Self-organization in the olfactory system: One shot odor recognition in insects, Biol Cyber, 93 (6): 436-446 (2005), doi:10.1007/s00422-005-0019-7
Nowotny insect olfaction model: [2]; Traub-Miles Hodgkin-Huxley neuron model: [5]
Locust olfactory system (Nowotny et al. 2005) with user-defined synapses ======================================================================== This examples recapitulates the exact same model as MBody1_project, but with user-defined model types for neurons and synapses. Also sparse connectivity is used instead of dense. The way user-defined types are used should be very instructive to advanced users wishing to do the same with their models. This example project contains a helper executable called "generate_run", which also prepares additional synapse connectivity and input pattern data, before compiling and executing the model. To compile it, navigate to genn/userproject/MBody_userdef_project and type: nmake /f WINmakefile for Windows users, or: make for Linux, Mac and other UNIX users. USAGE ----- generate_run <0(CPU)/1(GPU)/n(GPU n-2)> <nAL> <nKC> <nLH> <nDN> <gScale> <DIR> <MODEL> Mandatory parameters: CPU/GPU: Choose whether to run the simulation on CPU (`0`), auto GPU (`1`), or GPU (n-2) (`n`). nAL: Number of neurons in the antennal lobe (AL), the input neurons to this model nKC: Number of Kenyon cells (KC) in the "hidden layer" nLH: Number of lateral horn interneurons, implementing gain control nDN: Number of decision neurons (DN) in the output layer gScale: A general rescaling factor for snaptic strength outname: The base name of the output location and output files model: The name of the model to execute, as provided this would be `MBody1` Optional arguments: DEBUG=0 or DEBUG=1 (default 0): Whether to run in a debugger FTYPE=DOUBLE of FTYPE=FLOAT (default FLOAT): What floating point type to use REUSE=0 or REUSE=1 (default 0): Whether to reuse generated connectivity from an earlier run CPU_ONLY=0 or CPU_ONLY=1 (default 0): Whether to compile in (CUDA independent) "CPU only" mode. An example invocation of generate_run is: generate_run.exe 1 100 1000 20 100 0.0025 outname MBody_userdef for Windows users, or: ./generate_run 1 100 1000 20 100 0.0025 outname MBody_userdef for Linux, Mac and other UNIX users. Such a command would generate a locust olfaction model with 100 antennal lobe neurons, 1000 mushroom body Kenyon cells, 20 lateral horn interneurons and 100 mushroom body output neurons, and launch a simulation of it on a CUDA-enabled GPU using single precision floating point numbers. All output files will be prefixed with "outname" and will be created under the "outname" directory. In more details, what generate_run program does is: a) use some other tools to generate the appropriate connectivity matrices and store them in files. b) build the source code for the model by writing neuron numbers into ./model/sizes.h, and executing "genn-buildmodel.sh ./model/MBody_userdef.cc". c) compile the generated code by invoking "make clean && make" running the code, e.g. "./classol_sim r1 1". Another example of an invocation would be: generate_run.exe 0 100 1000 20 100 0.0025 outname MBody_userdef FTYPE=DOUBLE CPU_ONLY=1 for Windows users, or: ./generate_run 0 100 1000 20 100 0.0025 outname MBody_userdef FTYPE=DOUBLE CPU_ONLY=1 for Linux, Mac and other UNIX users. MODEL INFORMATION ----------------- For information regarding the locust olfaction model implemented in this example project, see: T. Nowotny, R. Huerta, H. D. I. Abarbanel, and M. I. Rabinovich Self-organization in the olfactory system: One shot odor recognition in insects, Biol Cyber, 93 (6): 436-446 (2005), doi:10.1007/s00422-005-0019-7
Nowotny insect olfaction model: [2]; Traub-Miles Hodgkin-Huxley neuron model: [5]
Locust olfactory system (Nowotny et al. 2005) ============================================= This example is very similar to the MBody1_project example. The only difference is that PN to KC connections are defined with the INDIVIDUALID mechanism. To compile it, navigate to genn/userproject/MBody_individualID_project and type: nmake /f WINmakefile for Windows users, or: make for Linux, Mac and other UNIX users. USAGE ----- generate_run <0(CPU)/1(GPU)/n(GPU n-2)> <nAL> <nKC> <nLH> <nDN> <gScale> <DIR> <MODEL> Mandatory parameters: CPU/GPU: Choose whether to run the simulation on CPU (`0`), auto GPU (`1`), or GPU (n-2) (`n`). nAL: Number of neurons in the antennal lobe (AL), the input neurons to this model nKC: Number of Kenyon cells (KC) in the "hidden layer" nLH: Number of lateral horn interneurons, implementing gain control nDN: Number of decision neurons (DN) in the output layer gScale: A general rescaling factor for snaptic strength outname: The base name of the output location and output files model: The name of the model to execute, as provided this would be `MBody1` Optional arguments: DEBUG=0 or DEBUG=1 (default 0): Whether to run in a debugger FTYPE=DOUBLE of FTYPE=FLOAT (default FLOAT): What floating point type to use REUSE=0 or REUSE=1 (default 0): Whether to reuse generated connectivity from an earlier run CPU_ONLY=0 or CPU_ONLY=1 (default 0): Whether to compile in (CUDA independent) "CPU only" mode. An example invocation of generate_run is: generate_run.exe 1 100 1000 20 100 0.0025 outname MBody_individualID for Windows users, or: ./generate_run 1 100 1000 20 100 0.0025 outname MBody_individualID for Linux, Mac and other UNIX users. Such a command would generate a locust olfaction model with 100 antennal lobe neurons, 1000 mushroom body Kenyon cells, 20 lateral horn interneurons and 100 mushroom body output neurons, and launch a simulation of it on a CUDA-enabled GPU using single precision floating point numbers. All output files will be prefixed with "outname" and will be created under the "outname" directory. In more details, what generate_run program does is: a) use some other tools to generate the appropriate connectivity matrices and store them in files. b) build the source code for the model by writing neuron numbers into ./model/sizes.h, and executing "genn-buildmodel.sh ./model/MBody_individualID.cc". c) compile the generated code by invoking "make clean && make" running the code, e.g. "./classol_sim r1 1". Another example of an invocation would be: generate_run.exe 0 100 1000 20 100 0.0025 outname MBody_individualID FTYPE=DOUBLE CPU_ONLY=1 for Windows users, or: ./generate_run 0 100 1000 20 100 0.0025 outname MBody_individualID FTYPE=DOUBLE CPU_ONLY=1 for Linux, Mac and other UNIX users. MODEL INFORMATION ----------------- For information regarding the locust olfaction model implemented in this example project, see: T. Nowotny, R. Huerta, H. D. I. Abarbanel, and M. I. Rabinovich Self-organization in the olfactory system: One shot odor recognition in insects, Biol Cyber, 93 (6): 436-446 (2005), doi:10.1007/s00422-005-0019-7
Nowotny insect olfaction model: [2]; Traub-Miles Hodgkin-Huxley neuron model: [5]
Locust olfactory system (Nowotny et al. 2005) ============================================= A variation of the \ref ex_mbody example using synaptic delays. In this example, the Kenyon Cell-Decision Neuron synapses are delayed by (5 * DT) ms, and the Decision Neuron-Decision Neuron synapses are delayed by (3 * DT) ms. The example is intended to test the operation of synapses which have a combination of delayed spike propagation and STDP (plasticity). This example project contains a helper executable called "generate_run", which also prepares additional synapse connectivity and input pattern data, before compiling and executing the model. To compile it, navigate to genn/userproject/MBody_delayedSyn_project and type: nmake /f WINmakefile for Windows users, or: make for Linux, Mac and other UNIX users. USAGE ----- generate_run <0(CPU)/1(GPU)/n(GPU n-2)> <nAL> <nKC> <nLH> <nDN> <gScale> <DIR> <MODEL> Mandatory parameters: CPU/GPU: Choose whether to run the simulation on CPU (`0`), auto GPU (`1`), or GPU (n-2) (`n`). nAL: Number of neurons in the antennal lobe (AL), the input neurons to this model nKC: Number of Kenyon cells (KC) in the "hidden layer" nLH: Number of lateral horn interneurons, implementing gain control nDN: Number of decision neurons (DN) in the output layer gScale: A general rescaling factor for snaptic strength outname: The base name of the output location and output files model: The name of the model to execute, as provided this would be `MBody1` Optional arguments: DEBUG=0 or DEBUG=1 (default 0): Whether to run in a debugger FTYPE=DOUBLE of FTYPE=FLOAT (default FLOAT): What floating point type to use REUSE=0 or REUSE=1 (default 0): Whether to reuse generated connectivity from an earlier run CPU_ONLY=0 or CPU_ONLY=1 (default 0): Whether to compile in (CUDA independent) "CPU only" mode. An example invocation of generate_run is: generate_run.exe 1 100 1000 20 100 0.0025 outname MBody_delayedSyn for Windows users, or: ./generate_run 1 100 1000 20 100 0.0025 outname MBody_delayedSyn for Linux, Mac and other UNIX users. Such a command would generate a locust olfaction model with 100 antennal lobe neurons, 1000 mushroom body Kenyon cells, 20 lateral horn interneurons and 100 mushroom body output neurons, and launch a simulation of it on a CUDA-enabled GPU using single precision floating point numbers. All output files will be prefixed with "outname" and will be created under the "outname" directory. In more details, what generate_run program does is: a) use some other tools to generate the appropriate connectivity matrices and store them in files. b) build the source code for the model by writing neuron numbers into ./model/sizes.h, and executing "genn-buildmodel.sh ./model/MBody_delayedSyn.cc". c) compile the generated code by invoking "make clean && make" running the code, e.g. "./classol_sim r1 1". Another example of an invocation would be: generate_run.exe 0 100 1000 20 100 0.0025 outname MBody_delayedSyn FTYPE=DOUBLE CPU_ONLY=1 for Windows users, or: ./generate_run 0 100 1000 20 100 0.0025 outname MBody_delayedSyn FTYPE=DOUBLE CPU_ONLY=1 for Linux, Mac and other UNIX users. MODEL INFORMATION ----------------- For information regarding the locust olfaction model implemented in this example project, see: T. Nowotny, R. Huerta, H. D. I. Abarbanel, and M. I. Rabinovich Self-organization in the olfactory system: One shot odor recognition in insects, Biol Cyber, 93 (6): 436-446 (2005), doi:10.1007/s00422-005-0019-7
Nowotny insect olfaction model: [2]; Traub-Miles Hodgkin-Huxley neuron model: [5]
Genetic algorithm for tracking parameters in a HH model cell ============================================================ This example simulates a population of Hodgkin-Huxley neuron models on the GPU and evolves them with a simple guided random search (simple GA) to mimic the dynamics of a separate Hodgkin-Huxley neuron that is simulated on the CPU. The parameters of the CPU simulated "true cell" are drifting according to a user-chosen protocol: Either one of the parameters gNa, ENa, gKd, EKd, gleak, Eleak, Cmem are modified by a sinusoidal addition (voltage parameters) or factor (conductance or capacitance) - protocol 0-6. For protocol 7 all 7 parameters undergo a random walk concurrently. To compile it, navigate to genn/userproject/HHVclampGA_project and type: nmake /f WINmakefile for Windows users, or: make for Linux, Mac and other UNIX users. USAGE ----- generate_run <CPU=0, GPU=1> <protocol> <nPop> <totalT> <outdir> Mandatory parameters: GPU/CPU: Whether to use the GPU (1) or CPU (0) for the model neuron population protocol: Which changes to apply during the run to the parameters of the "true cell" nPop: Number of neurons in the tracking population totalT: Time in ms how long to run the simulation outdir: The directory in which to save results Optional arguments: DEBUG=0 or DEBUG=1 (default 0): Whether to run in a debugger FTYPE=DOUBLE of FTYPE=FLOAT (default FLOAT): What floating point type to use REUSE=0 or REUSE=1 (default 0): Whether to reuse generated connectivity from an earlier run CPU_ONLY=0 or CPU_ONLY=1 (default 0): Whether to compile in (CUDA independent) "CPU only" mode. An example invocation of generate_run is: generate_run.exe 1 -1 12 200000 test1 for Windows users, or: ./generate_run 1 -1 12 200000 test1 for Linux, Mac and other UNIX users. This will simulate nPop= 5000 Hodgkin-Huxley neurons on the GPU which will for 1000 ms be matched to a Hodgkin-Huxley neuron where the parameter gKd is sinusoidally modulated. The output files will be written into a directory of the name test1_output, which will be created if it does not yet exist. Another example of an invocation would be: generate_run.exe 0 -1 12 200000 test1 FTYPE=DOUBLE CPU_ONLY=1 for Windows users, or: ./generate_run 0 -1 12 200000 test1 FTYPE=DOUBLE CPU_ONLY=1 for Linux, Mac and other UNIX users.
Traub-Miles Hodgkin-Huxley neuron model: [5]
1.8.11 
