News (old posts, page 2)

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.)

Building sparse connections

We just added a new feature for building sparse connections: the sparseness keyword now accepts functions in the same way as the weight keyword, e.g.:

[python] myconnection.connect_random(group1,group2,0.1,weight=1nS,sparseness=exp(-abs(i-j).1)) [/python]

makes random synapses between neurons with a distance-dependent probability (assuming the neurons are topographically arranged, with a linear topology).

Brian 1.2

We have just released Brian 1.2.

The major feature of this release is the model fitting toolbox, designed for automatic fitting of spiking neural models to recorded data. The toolbox is capable of using multiple CPUs or GPUs, across multiple machines. For example, in our lab we use 3 computers with 2 GPUs each to get a 300x speed increase compared to using a single CPU.

Other features of this release include some support for real time plotting as the simulation runs and some important bug fixes. See below for the complete list of changes.

With this release, we are moving away from the old Sourceforge site to the new Brian Trac kindly hosted by Neural Ensemble. We have also been working on our release tools, making it much easier to produce new releases. We now plan to do fairly frequent 'quick releases' which will be less thoroughly tested, but useful for those who want the latest features without having to much around with the SVN version.

Major features:

  • Model fitting toolbox (library.modelfitting)
Minor features:
  • New real-time refresh= options added to plotting functions
  • Gamma factor in utils.statistics
  • New RegularClock object
  • Added brian_sample_run function to test installation in place of nose tests
Improvements:
  • Speed improvements to monitors and plotting functions
  • Sparse matrix support improved, should work with scipy versions up to 0.7.1
  • Various improvements to brian.hears (still experimental though)
  • Parameters now picklable
  • Made Equations picklable
Bug fixes:
  • Fixed major bug with subgroups and connections (announced on webpage)
  • Fixed major bug with multiple clocks (announced on webpage)
  • No warnings with Python 2.6
  • Minor bugfix to TimedArray caused by floating point comparisons
  • Bugfix: refractory neurons could fire in very extreme circumstances
  • Fixed bug with DelayConnection not setting max_delay
  • Fixed bug with STP
  • Fixed bug with weight=lambda i,j:rand()
New examples:
  • New multiprocessing examples
  • Added polychronisation example
  • Added modelfitting examples
  • Added examples of TimedArray and linked_var
  • Added examples of using derived classes with Brian
  • Realtime plotting example