New paper on Brian Hears

The following paper on Brian Hears was just accepted for publication:

Fontaine B, Goodman DFM, Benichoux V, Brette R (2011). Brian Hears: online auditory processing using vectorisation over channels. Frontiers in Neuroinformatics (in press) [preprint]

Abstract The human cochlea includes about 3000 inner hair cells which filter sounds at frequencies between 20 Hz and 20 kHz. This massively parallel frequency analysis is reflected in models of auditory processing, which are often based on banks of filters. However, existing implementations do not exploit this parallelism. Here we propose algorithms to simulate these models by vectorising computation over frequency channels, which are implemented in "Brian Hears", a library for the spiking neural network simulator package "Brian". This approach allows us to use high-level programming languages such as Python, because with vectorised operations, the computational cost of interpretation represents a small fraction of the total cost. This makes it possible to define and simulate complex models in a simple way, while all previous implementations were model-specific. In addition, we show that these algorithms can be naturally parallelised using graphics processing units, yielding substantial speed improvements. We demonstrate these algorithms with several state-of-the-art cochlear models, and show that they compare favorably with existing, less flexible, implementations.

New paper on Playdoh

The following paper has just been accepted for publication:

Rossant C, Fontaine B, Goodman DFM (2011). Playdoh: a lightweight Python package for distributed computing and optimisation. Journal of Computational Science (in press)

Abstract Parallel computing is now an essential paradigm for high performance scientific computing. Most existing hardware and software solutions are expensive or difficult to use. We developed Playdoh, a Python library for distributing computations across the free computing units available in a small network of multicore computers. Playdoh supports independent and loosely coupled parallel problems such as global optimisations, Monte Carlo simulations and numerical integration of partial differential equations. It is designed to be lightweight and easy to use and should be of interest to scientists wanting to turn their lab computers into a small cluster at no cost.

Brian users might find the package (available here) and the paper (preprint) interesting.

New Brian showcase

We've just added a new Showcase section to the website. Here we'll list any projects that make use of or include Brian, or any cool demos and so forth developed by other people. When we add new things to the showcase we'll post a News item on the website.

Brian 1.3

The 1.3 release of Brian is out!

The major change in this version is the addition of the Brian.hears package for auditory modelling. This version also includes an update to the toolbox for fitting neural models to electrophysiological recordings (which now uses version 0.3 of the parallel optimization package Playdoh), remote control of Brian scripts, and experimental support for code generation for C and GPU. There are also a number of other new features, bug fixes and improvements (full list below).

Brian is also available from the NeuroDebian repository: pre-packaged for all recent Debian and Ubuntu releases.

Brian is being developed by Romain Brette and Dan Goodman. This version also includes contributions by Bertrand Fontaine, Cyrille Rossant, Victor Benichoux and Boris Gourévitch.

New features since 1.2.1

Major features
  • Added Brian.hears auditory library
Minor features
  • Added new brian.tools.datamanager.DataManager, moved from brian.experimental
  • reinit(states=False) will now not reset NeuronGroup state variables to 0.
  • modelfitting now has support for refractoriness
  • New examples in misc: after_potential, non_reliability, reliability,
  • van_rossum_metric, remotecontrolserver, remotecontrolclient
  • New experimental.neuromorphic package
  • Van Rossum metric added
Improvements
  • SpikeGeneratorGroup is faster for large number of events ("gather" option).
  • Speed improvement for pure Python version of sparse matrix preparation
  • Speed improvements for spike propagation weave code (50-100% faster).
  • Clocks have been changed and should now behave more predictably. In addition, you can now specify an order attribute for clocks.
  • modelfitting is now based on playdoh 0.3
  • modelfitting can now use euler/exp.euler or RK2 integration schemes
  • Loading AER data is much faster
  • Freezing now uses higher precision (used to only use 12sf now uses 17sf)
Bug fixes
  • Bug in STDP with small values for wmin/wmax fixed (ticket #63)
  • Equations/aliases now work correctly in STDP (ticket #56)
  • Bug in sparse matrices introduced in scipy 0.8.0 fixed
  • Bug in TimedArray when dt keyword is used now fixed (thanks to Adrien Wohrer for pointing out the bug).
  • Units now work correctly in STDP (ticket #60)
  • STDP raises an error if operations are reordered (ticket #57)
  • linked_var works with static vars (equations) (ticket #68)
  • Changing clock.t during a run won't end the run
  • Fixed ticket #66 (unit bug)
  • Fixed ticket #64 (bug with freeze)
  • Can now run a network with no group
  • Exception handling now works properly for C version of circular spike container
  • ccircular now builds correctly on linux and 64 bit
Internal changes
  • brian.connection deprecated and replaced by subpackage brian.connections, making the code structure much more straightforward and setting up for future work on code generation, etc.

Brian paper amongst most cited in Frontiers

We have just been informed by the Frontiers Editorial Staff that our first paper on Brian for Frontiers in Neuroinformatics was the second most cited paper across all the Frontiers journals since its publication in 2008.

This paper was published as part of a special issue on Python in neuroscience which appears to have been very successful. According to my Publish or Perish search, six other articles from the same issue are in the top 25 most cited papers in Frontiers journals since 2008, comprising papers on PyNN, Vision Egg, PyNEST, NEURON, Python for information theory, and MDP.

New paper on vectorised algorithms

We have a new paper in Neural Computation (in press) "Vectorised algorithms for spiking neural network simulation", preprint available here. Abstract follows:

High-level languages (Matlab, Python) are popular in neuroscience because they are flexible and accelerate development. However, for simulating spiking neural networks, the cost of interpretation is a bottleneck. We describe a set of algorithms to simulate large spiking neural networks efficiently with high-level languages using vector-based operations. These algorithms constitute the core of Brian, a spiking neural network simulator written in the Python language. Vectorised simulation makes it possible to combine the flexibility of high-level languages with the computational efficiency usually associated with compiled languages.

New paper on code generation

We have just had a new paper accepted for the journal Neuroinformatics, entitled "Code generation: a strategy for neural network simulators". You can download a provisional PDF here. Abstract included below:

We demonstrate a technique for the design of neural network simulation software, runtime code generation. This technique can be used to give the user complete flexibility in specifying the mathematical model for their simulation in a high level way, along with the speed of code written in a low level language such as C++. It can also be used to write code only once but target different hardware platforms, including inexpensive high performance graphics processing units (GPUs). Code generation can be naturally combined with computer algebra systems to provide further simplification and optimisation of the generated code. The technique is quite general and could be applied to any simulation package. We demonstrate it with the "Brian" simulator (http://www.briansimulator.org).

The code generation features are already available in the current version of Brian, although undocumented as yet (see the Preferences section of the documentation for information on how to activate code generation).

Brian 1.2.1

We have just released Brian 1.2.1.

This is mostly a bug fixing release, and minor new features. One highlight is the new remote control system which allows you to interact with a Brian script as it is running - e.g. changing parameter values, plotting intermediate results, etc. Also, GPU support on 64 bit and Linux machines is now much better.

Major features:

  • New remote controlling of running Brian scripts via RemoteControlServer and RemoteControlClient.

Minor features:

  • New module tools.io
  • weight and sparseness can now both be functions in connect_random
  • New StateHistogramMonitor object
  • clear now has a new keyword all which allows you to destroy all Brian objects regardless of whether or not they would be found by MagicNetwork. In addition, garbage collection is called after a clear.
  • New method StateMonitor.insert_spikes to have spikes on voltage traces.

Improvements

  • The sparseness keyword in connect_random can be a function
  • Added 'wmin' to STDP
  • You can now access STDP internal variables, e.g. stdp.A_pre, and monitor them by doing e.g. StateMonitor(stdp.pre_group, 'A_pre')
  • STDP now supports nonlinear equations and parameters
  • refractory can now be a vector (see docstring for NeuronGroup) for constant resets.
  • modelfitting now uses playdoh library
  • C++ compiled code is now much faster thanks to adding -ffast-math switch to gcc, and there is an option which allows you to set your own compiler switches, for example -march=native on gcc 4.2+.
  • SpikeGeneratorGroup now has a spiketimes attribute to reset the list of spike times.
  • StateMonitor now caches values in an array, improving speed for M[i] operation and resolving ticket #53

Bug fixes

  • Sparse matrices with some versions of scipy
  • Weave now works on 64 bit platforms with 64 bit Python
  • Fixed bug introduced in 1.2.0 where dense DelayConnection structures would not propagate any spikes
  • Fixed bug where connect* functions on DelayConnection didn't work with subgroups but only with the whole group.
  • Fixed bug with linked_var from subgroups not working
  • Fixed bug with adding Equations objects together using a shared base equation (ticket #9 on the trac)
  • unit_checking=False now works (didn't do anything before)
  • Fixed bug with using Equations object twice (for two different NeuronGroups)
  • Fixed unit checking bug and ZeroDivisionError (ticket #38)
  • Fixed rare problems with spikes being lost due to wrong size of SpikeContainer, it now dynamically adapts to the number of spikes.
  • Fixed ticket #5, ionic_currents did not work with units off
  • Fixed ticket #6, Current+MembraneEquation now works
  • Fixed bug in modelfitting : the fitness was not computed right with CPUs.
  • Fixed bug in modelfitting with random seeds on Unix systems.
  • brian.hears.filtering now works correctly on 64 bit systems

Removed features

  • Model has now been removed from Brian (it was deprecated in 1.1).

Brian tutorial slides

I gave a relatively technical tutorial on using Brian that might be of interest more generally. The tutorial was done via Skype so I could record what I was saying and insert that into the Powerpoint slides. You can download both versions below:

Unfortunately, I can't find a good way to convert this into a video file or I would upload that / put it on YouTube - let me know if you have a good, free way of doing it. (None of the programs I found online could correctly handle the transitions and the audio files correctly.)