 |
GeNN
3.3.0
GPU enhanced Neuronal Networks (GeNN)
|
|
GeNN
3.3.0
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: msbuild SynDelay.vcxproj /p:Configuration=Release 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 BITMASK=0 or BITMASK=1 (default 0): Whether to use bitmasks to represent sparse PN->KC connectivity. DELAYED_SYNAPSES=0 or DELAYED_SYNAPSES=1 (default 0): Whether to simulate delays of (5 * DT) ms on KC->DN and of (3 * DT) ms on DN->DN synapse populations. 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: [3]; Traub-Miles Hodgkin-Huxley neuron model: [7]
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: [7]
Author: Alan Diamond, University of Sussex, 2014
This project recreates using GeNN the spiking classifier design used in the paper
"A neuromorphic network for generic multivariate data classification"
Authors: Michael Schmuker, Thomas Pfeil, Martin Paul Nawrota
The classifier design is based on an abstraction of the insect olfactory system.
This example uses the IRIS stadard data set as a test for the classifier
BUILD / RUN INSTRUCTIONS
Install GeNN from the internet released build, following instruction on setting your PATH etc
Start a terminal session
cd to this project directory (userproject/Model_Schmuker_2014_project)
To build the model using the GENN meta compiler type:
genn-buildmodel.sh Model_Schmuker_2014_classifier.cc
for Linux, Mac and other UNIX systems, or:
genn-buildmodel.bat Model_Schmuker_2014_classifier.cc
for Windows systems (add -d for a debug build).
You should only have to do this at the start, or when you change your actual network model (i.e. editing the file Model_Schmuker_2014_classifier.cc )
Then to compile the experiment plus the GeNN created C/CUDA code type:-
make
for Linux, Mac and other UNIX users (add DEBUG=1 if using debug mode), or:
msbuild Schmuker2014_classifier.vcxproj /p:Configuration=Release
for Windows users (change Release to Debug if using debug mode).
Once it compiles you should be able to run the classifier against the included Iris dataset.
type
./experiment .
for Linux, Mac and other UNIX systems, or:
Schmuker2014_classifier .
for Windows systems.
This is how it works roughly.
The experiment (experiment.cu) controls the experiment at a high level. It mostly does this by instructing the classifier (Schmuker2014_classifier.cu) which does the grunt work.
So the experiment first tells the classifier to set up the GPU with the model and synapse data.
Then it chooses the training and test set data.
It runs through the training set , with plasticity ON , telling the classifier to run with the specfied observation and collecting the classifier decision.
Then it runs through the test set with plasticity OFF and collects the results in various reporting files.
At the highest level it also has a loop where you can cycle through a list of parameter values e.g. some threshold value for the classifier to use. It will then report on the performance for each value. You should be aware that some parameter changes won't actually affect the classifier unless you invoke a re-initialisation of some sort. E.g. anything to do with VRs will require the input data cache to be reset between values, anything to do with non-plastic synapse weights won't get cleared down until you upload a changed set to the GPU etc.
You should also note there is no option currently to run on CPU, this is not due to the demanding task, it just hasn't been tweaked yet to allow for this (small change).
1.8.13