Neural Ensemble News

BrainScaleS/FACETS CodeJam #5 registration now open

2012-01-27T14:36:00.002+01:00

Registration is now open for the 5th BrainScaleS/FACETS CodeJam workshop, which will take place March 14th-16th, 2011 in Edinburgh.

The goal of the CodeJam workshops is to catalyze open-source, collaborative software development in computational and systems neuroscience and neuroinformatics (especially, but not exclusively, using Python), by bringing together researchers, students and engineers to share ideas, present their work, and write code together. The general format of the workshops is to dedicate the mornings to invited and contributed talks, leaving the afternoons free for discussions and code sprints.

For the 5th BrainScaleS/FACETS CodeJam, the main theme of the meeting will be convergence in computational neuroscience software: recent developments to promote interoperability of modelling, simulation and data analysis tools and future efforts to develop common tools and libraries. We are planning sessions on:

Neuronal network modelling
Code generation for neuron and synapse models
Multicompartmental neuron modelling in Python
Data analysis tools for computational and systems neuroscience
Best practices for running an open-source software project

More details on the program and invited speakers will follow soon.

We invite contributions on any topic related to software in neuroscience, but especially on topics related to the main theme and planned sessions. If you have ideas for organising code sprints, whether a feature that you would like to see added to an existing tool or an idea for new software, please also let us know.

The meeting is being organised by Andrew Davison, Mike Hull, Abigail Morrison, Eilif Muller, Miha Pelko and Laurent Perrinet.

Registration & Further Information

The registration deadline is 19th February 2012, and is limited to 50 participants.

Please consult the meeting website at http://neuralensemble.org/meetings/CodeJam5 for registration and further information.

5th INCF Congress of Neuroinformatics: Call for Workshop Proposals

2011-12-07T13:48:00.001+01:00

5th INCF Congress of Neuroinformatics: Munich, Sept 10 - 12, 2012

Call for Workshop Proposals!

Neuroinformatics 2012 will feature three workshops organized by the program committee and an additional three parallel workshops which will be selected from submitted proposals. This is a tremendous opportunity to host your own workshop with the topic and speakers of your choice!

MORE INFORMATION

WORKSHOP PROPOSAL SUBMISSION

Neuroinformatics 2012 regular workshops:

Function-structure relationship in microcircuitry (Chair: Keiji Tanaka)
Systems Biology of the Neuron (Chair: Mary Kennedy)
If there is a data deluge, where are the data? (Chair: Tim Clark)

Sumatra 0.3 released

2011-03-14T16:55:00.000+01:00

We would like to announce the release of version 0.3 of Sumatra, a tool for automated tracking of simulations and computational analyses so as to be able to easily replicate them at a later date.

The main changes are:

Improved documentation, now hosted at http://packages.python.org/Sumatra/
It is now possible to have records from multiple projects within a single record store. For example, this allows having a central record store which collects simulation results from all projects, rather than having one store per project.
Generalized the assumed command line format for running simulations/analyses. Before we assumed "executable main_script parameter_file", now smt support multiple script files with arbitrary arguments and options. Arguments which look like input data files are registered, arguments which look like (and behave like) parameter files are treated as such.
Can now migrate records from one record store to another ("smt sync" command).
Can now use any directory below the project directory as the working directory .
Can now create project-specific templates for the web interface.
Added support for the GENESIS 2 simulator.
Added support for the Bazaar version control system.
Added an "upgrade" command to smt, to upgrade projects created with previous versions (this will happen automatically in future, but we're playing it safe for now).

Sumatra 0.3.0 may be downloaded from PyPI or from the INCF Software Center. Support is available from the (newly-created) sumatra-users Google Group.

Python in Neuroscience satellite 2011

2011-03-08T14:40:00.000+01:00

Paris, Ecole Normale Supérieure, August 29-30 2011

The “Python in Neuroscience” workshop, a satellite meeting to EuroSciPy 2011, aims at gathering researchers who develop software tools in different branches of neuroscience in order to share ideas, concepts, tools and to foster collaborative projects based on the Python language.

Main Topics

    * tools for neural simulation,
    * electrophysiology data analysis,
    * data management and databasing in neuroimaging and neuroscience,
    * stimulus generation
    * neuroimaging data processing
    * workflows and pipelines for data processing
    * massive computation facilities for simulation and data analysis in neuroscience
    * visualization tools in neuroscience and neuroimaging

Call for Contributions

We are soliciting contributions that deal with the above topics using Python tools, including research projects and software presentations, with the hope of interesting a broader community, including e.g. neuroscience and neuroimaging.

Important dates

Abstract submission deadline: June 1st, 2011
Final program: June 30th, 2011
Workshop: August 28-20, 2011

Submission guidelines

    * We solicit talk proposals in the form of a one-page long abstract.
    * The only condition for acceptance is that the abstract fits well with the workshop theme.
    * Oral and poster presentations will be allocated depending on the number of contributions.

Website

http://www.euroscipy.org/card/neurosciences_2011
Contact: bertrand.thirion@inria.fr

Chairs

* Bertrand Thirion (INRIA Saclay)
* Romain Brette (ENS Paris)

Program committee

    * Eilif Müller, Blue Brain Project, EPFL Laussane
    * Gaël Varoquaux, INSERM U992, Saclay
    * Raphaël Ritz, INCF, Stockholm, Sweden
    * Laurent Perrinet, INCM, Marseille
    * Andrew Davison, UNIC, CNRS, Gif

PyNN 0.7.0 released

2011-02-04T16:09:00.000+01:00

PyNN 0.7.0 is available for download from PyPI and from the INCF Software Center. Documentation is available at http://neuralensemble.org/PyNN.

This release sees a major extension of the API with the addition of the PopulationView and Assembly classes, which aim to make building large, structured networks much simpler and cleaner. A PopulationView allows a subset of the neurons from a Population to be encapsulated in an object. We call it a "view", rather than a "sub-population", to emphasize the fact that the neurons are not copied: they are the same neurons as in the parent Population, and any operations on either view or parent (setting parameter values, recording, etc.) will be reflected in the other. An Assembly is a list of Population and/or PopulationView objects, enabling multiple cell types to be encapsulated in a single object. PopulationView and Assembly objects behave in most ways like Population: you can record them, connect them using a Projection, you can have views of views...

The "low-level API" (rechristened "procedural API") has been reimplemented in terms of Population and Projection. For example, create() now returns a Population object rather than a list of IDs, and connect() returns a Projection object. This change should be almost invisible, since Population now behaves very much like a list of IDs (can be sliced, joined, etc.).

There has been a major change to cell addressing: Populations now always store cells in a one-dimensional array, which means cells no longer have an address but just an index. To specify the spatial structure of a Population, pass a Structure object to the constructor, e.g.

p = Population((12,10), IF_cond_exp)

is now

p = Population(120, IF_cond_exp, structure=Grid2D(1.2))

although the former syntax still works, for backwards compatibility. The reasons for doing this are:

we can now have more interesting structures than just grids
efficiency (less juggling addresses, flattening)
simplicity (less juggling addresses, less code).

The API for setting initial values has changed: this is now done via the initialize() function or the Population.initialize() method, rather than by having v_init and similar parameters for cell models.

Other API changes:

- simplification of the record_X() methods.
- enhanced describe() methods: can now use Jinja2 or Cheetah templating engines to produce much nicer, better formatted network descriptions.
- connections and neuron positions can now be saved to various binary formats as well as to text files.
- added some new connectors: SmallWorldConnector and CSAConnector (CSA = Connection Set Algebra).
- native neuron and synapse models are now supported using a NativeModelType subclass, rather than specified as strings. This simplifies the code internally and increases the range of PyNN functionality that can be used with native models (e.g. you can now record any variable from a native NEST or NEURON model). For NEST, there is a class factory native_cell_type(), for NEURON the NativeModelType subclasses have to be written by hand.

Backend changes:

the NEST backend has been updated to work with NEST version 2.0.0rc2.
the Brian backend has seen extensive work on performance and on bringing it to feature parity with the other backends.

Contributors

I'd like to thank everyone who has contributed to this release: Daniel Brüderle, Eilif Muller, Mikael Djurfeldt, Michael Schmucker and especially Pierre Yger, who has done amazing work on the Brian backend, on implementing my wish list of features for the Assembly class, and in many other areas, while at the same time successfully completing and defending his PhD thesis. Thanks also to everyone who has reported bugs or requested improvements.

What is PyNN?

PyNN (pronounced 'pine' ) is a simulator-independent language for building neuronal network models.

In other words, you can write the code for a model once, using the PyNN API and the Python programming language, and then run it without modification on any simulator that PyNN supports (currently NEURON, NEST, PCSIM and Brian).

Even if you don't wish to run simulations on multiple simulators, you may benefit from writing your simulation code using PyNN's powerful, high-level interface. In this case, you can use any neuron or synapse model supported by your simulator, and are not restricted to the standard models.

PyNN is also being used as a user-friendly interface to neuromorphic hardware systems.

The code is released under the CeCILL licence (GPL-compatible).

Open Research Computation: a new journal for publications describing scientific software

2010-12-13T11:36:00.001+01:00

Cameron Neylon has just announced a new journal, "Open Research Computation", published by BioMed Central. The goals of the journal are to promote sharing of high-quality scientific software (e.g. there must be a test suite with 100% code coverage), promote discussion of best practice in research software development, and to enable researchers to be rewarded through publication for the time spent on developing software tools for others to use.

The editorial board contains many familiar names from the scientific Python community, including Titus Brown, Hans-Petter Langtangen, Jarrod Millman, Fernando Perez and Gaël Varoquaux, and others from the reproducible research community such as Peter Murray-Rust and Victoria Stodden.

The goals of Open Research Computation seem to be very well aligned with those of the NeuralEnsemble community, and I encourage you all to think about submitting manuscripts there.

Society for Neuroscience meeting 2010: a Python perspective

2010-11-26T17:11:00.000+01:00

Last week I was at the annual meeting of the Society for Neuroscience (SfN) in San Diego. For those who aren't familiar with the meeting, it is huge, with over 30000 participants: it seemed as though every flight into San Diego on the day before the meeting was filled with people carrying poster tubes. Even as far away as Paris, the check-in line for every America-bound flight from Charles de Gaulle was bristling with posters.

The first few SfN meetings I went to, I exhausted myself trying to see every poster and every talk that could possibly be of interest (while lugging round several kilograms of abstract books and free journal samples from Publishers' Row). This time I focused on the early visual system (there was a particularly good symposium on colour vision) and on neuroinformatics (in particular database and simulation software) (and Publishers' Row this year was at the far, far end of the enormous poster/exhibitors hall - I never got that far).

Anyway, this is a report on the meeting from a software (and particularly Python software) perspective.

NEURON and Python workshop

On Saturday morning, I took part in a workshop/seminar on NEURON+Python, organised by Tom McTavish, Ted Carnevale and Tom Morse from Yale. This was apparently hugely over-subscribed, which certainly reflects the large NEURON user community, but it is clear that all the participants were intrigued by the potential power that Python brings to this well-established simulator (in a related note, I was just told that the article we wrote about NEURON and Python is one of the 25 most-cited articles in the Frontiers in Neuroscience journal series).

The format was part traditional presentations, part interactive tutorial using Sage notebooks.

Tom McTavish gave an interative introduction to Python, and then to using Python with the NEURON simulator. Tom Morse talked about ModelDB, and Ted Carnevale discussed using Python and Hoc (NEURON's original scripting language) together. Tom Foutz presented Neuron3D, a Mayavi-based tool for working with 3D views of neurons, nuclei and electrodes in NEURON. This looked very nice, and reminded me of a couple of tools presented at the last CodeJam meeting, Mike Hull's morphforge and Michele Mattioni's NeuronVisio, both of which also use Mayavi. Mike was in San Diego at the meeting, so I introduced him to Tom, and they started hatching plans for some collaboration - watch this space. I talked about a miscellaneous bunch of stuff related to neuronal simulation and Python, including PyNN, Sumatra, NeuroTools, NeuralEnsemble.org and nrnutils.

Materials from the workshop will be available soon on the NEURON forum.

Posters

A search for "python" in the Neuroscience Meeting Planner gives nine abstracts, all of which refer to the programming language (it appears no-one is reporting research into the nervous system of the family Pythonidae). ("Matlab" gives 36 abstracts, so it's clear we've a way to go). I guess many more people probably use Python in their research, but at least this gives an idea of how many thought it was important enough to mention in the abstract.

The topics covered included neuroscience education (25.27), the role of relative ion channel densities in neuronal firing properties in tadpoles (46.8), the CARMEN e-science platform for neurophysiology data (107.1), web-based model presentation using NEURON and Sage (208.27), the eagerly-anticipated 2.0 release of the NEST simulator (208.28), modelling olfactory neurons (369.6), analysis of spectroscopy data in Alzheimer's disease (746.20), inference of brain connectivity (918.13), and boosting your research productivity using NeuroDebian (918.15).

I'll say more about CARMEN and NeuroDebian below.

Although I didn't visit the poster, the abstract on modelling the olfactory bulb external tufted cell (369.6) interests me because they implemented versions of the model in both Python and Matlab. The importance of implementing neuroscience models in at least two simulation environments as a way of checking the numerical methods of a given simulator don't impact the qualitative results and of improving the reproducibility of the model is a subject I've been banging on about for some time, so it's great to see that other people are also doing this. (Great to see this cell type being modelled, incidentally. When I find time to return to olfactory bulb modelling, I'll certainly follow up on this work).

I really liked Tom McTavish's poster (208.27) on using Sage to interact with NEURON models over the web. Another subject I often go on about is enhancing the reusability of neuronal models: building new models based on well-tested and well-understood existing components, rather than building from scratch every time, is something I think there is too little of in neuroscience at the moment, so tools that improve the accessibility, comprehensibility and testability of neuroscience models are to be welcomed. There is nothing NEURON-specific about Sage, of course: I think this is a tool that would be useful for any Python-supporting neuroscience simulator.

INCF booth

The International Neuroinformatics Coordinating Facility (INCF) had a booth at SfN, at which they had a program of live demonstrations of neuroinformatics software and resources (they also had a very comfy sofa), including a demo of a Python client for XNAT-based neuroimaging databases by Yannick Schwartz and colleagues from LNAO at NeuroSpin.

Neurodebian booth

Neurodebian is "a platform that provides a staging area for neuroscience software packages on their way into Debian". They had a booth at SfN, and I swung by to discuss packaging PyNN for Debian. I now have a short list of things to do to make PyNN suitable for packaging, so hopefully the 0.7.0 release will be available in NeuroDebian. Overall, they have an impressive selection of packages. I am almost convinced to try running NeuroDebian on our cluster, instead of Ubuntu. One package I need that is missing is mpi4py, but the Neurodebian guys are now planning to add that. Here is their own report on the meeting.

Other stuff

Some non-Python stuff is definitely worth a mention. I've been following the CARMEN project for some time. This is a UK-funded project to develop a portal for sharing of neuroscience data and analyses. They have now opened their portal to academic users. They are also responsible for a number of advances and fledgling standards in electrophysiology data sharing, including the MINI specification (Minimum Information about a Neuroscience Investigation) and the NDF (Neurophysiology Data translation Format) (not to be confused with NDF (Neurospaces Description Format) :-).

Gwen Jacobs was presenting the Yogo Data Management Framework, "a set of software tools created to rapidly build scientific data-management applications". I think this sort of tool - enabling straightforward customization of database systems for the needs of individual labs - is going to be essential in bringing some of the vast quantity of neuroscience data generated every year into a form where it can be shared, reanalyzed and reused. Although the system we're developing in my group, Helmholtz, is much more neuroscience-specific and less general than Yogo (and much less polished, at the moment), it was interesting to see that we've made many of the same architectural decisions, including building on top of a rapid-development web framework (Ruby on Rails for Yogo, Django in our case).

Finally, if you haven't already done so, check out the demo video for the Whole Brain Catalog, the software for which is open-source, and, I just saw, exposes a RESTful API.

The Debian Neuroscience Repository

2010-09-27T10:46:00.003+02:00

NeuroDebian (http://neuro.debian.net/) "aims to provide a turnkey
software platform for nearly all aspects of the neuroscientific
research process".

There's nothing specifically simulation-related there yet, as far as I can see, but it seems like this would be a good thing for NeuralEnsemble members to get involved with.

Mailing lists:

* neurodebian-users: Discussions and support of NeuroDebian users
http://lists.alioth.debian.org/mailman/listinfo/neurodebian-users

* neurodebian-upstream: General discussions and knowledge sharing
among developers of the neuroscience software
http://lists.alioth.debian.org/mailman/listinfo/neurodebian-upstream

* neurodebian-devel: Technical mailing list for discussions on
NeuroDebian development
http://lists.alioth.debian.org/mailman/listinfo/neurodebian-devel

Photos from CodeJam4

2010-07-12T23:21:00.002+02:00

Sumatra 0.2 released

2010-07-10T08:52:00.000+02:00

We would like to announce the release of version 0.2 of Sumatra, a tool for automated tracking of simulations and computational analyses so as to be able to easily replicate them at a later date.

The main changes are:

expanded the focus from just simulations to any command-line driven computation, e.g. analyses, graphing. This simply involved changes to the documentation and some renaming, e.g. SimProject is now just Project.
RecordStores can now contain records from multiple projects and multiple users. This makes it possible to keep all your records in a single database, and for different people to collaborate on the same project.
added support for the Git version control system. Sumatra requires your code to be stored in a version control system to ensure reproducibility, and now supports Git, Subversion and Mercurial.
removed the concept of record groups, since grouping can easily be achieved using tags.
Sumatra can now pass the record label to your main script, by appending it either to the command line or to the parameter file. This is very useful for separating the output files of different experiments into their own directories such that Sumatra can correctly link to them.
you can now tag a simulation/analysis at the same time you run it, using smt run, rather than having to remember to do this afterwards with smt tag.
added a @capture decorator, to make it easier to use Sumatra in your own Python scripts.
the web interface will now display the contents of any CSV files generated during your experiment as an HTML table.
added ConfigParserParameterSet. If you pass parameters to your simulation/analysis in a separate file, then Sumatra can store these parameters for future searching, provided it understands the parameter file format. The new class adds support for parameters stored in ConfigParser-style files (the existing supported formats are simple one-per-line key=value files and hierarchical, JSON-like NeuroTools parameter sets).

Sumatra 0.2 may be downloaded from the INCF Software Center or from PyPI.

Program & reg. deadline extension - FACETS CodeJam #4

2010-06-09T23:25:00.002+02:00

A preliminary program for the 4th annual FACETS CodeJam meeting (http://neuralensemble.org/codejam4) which will take place June 22nd-24th, 2010 in Marseille, France is now available here:

http://neuralensemble.org/meetings/CJ4_Preliminary_Program_v2.pdf

In addition, the registration deadline has been extended to June 13th, 2010. What are you waiting for? Register now!

The goal of the FACETS CodeJam workshops is to catalyze open-source, collaborative software development in computational and systems neuroscience and neuroinformatics, by bringing together researchers, students and engineers to share ideas, present their work, and write code together. The general format of the workshops is to dedicate the mornings to invited and contributed talks, leaving the afternoons free for discussions and code sprints.

For the 4th FACETS CodeJam, the main theme of the meeting will be workflows: what are the best practices for combining different tools (simulators, analysis tools, visualization tools, databases etc.) to ensure the efficient and reproducible flow of data and information from experiment conception to publication and archiving?

The meeting is being organised by:
Andrew Davison (UNIC-CNRS, Gif-sur-Yvette, France)
Abigail Morrison (BCCN-Freiburg, Germany)
Eilif Muller (BBP-EPFL, Lausanne, Switzerland)
Laurent Perrinet (INCM-CNRS, Marseille, France)

Please consult the meeting website at

http://neuralensemble.org/codejam4

for registration and further information.

GvR on "Python in the Scientific World"

2010-05-26T17:41:00.000+02:00

"Yesterday I attended a biweekly meeting of an informal a UC Berkeley group devoted to Python in science (Py4Science), organized by Fernando Perez. The format (in honor of my visit) was a series of 4-minute lightning talks about various projects using Python in the scientific world (at Berkeley and elsewhere) followed by an hourlong Q&A session. This meant I didn't have to do a presentation and still got to interact with the audience for an hour -- my ideal format.

I was blown away by the wide variety of Python use for scientific work. It looks like Python (with extensions like numpy) is becoming a standard tool for many sciences that need to process large amounts of data, from neuroimaging to astronomy. ..."

http://neopythonic.blogspot.com/2009/11/python-in-scientific-world.html

FACETS CodeJam #4 registration now open

2010-04-20T13:22:00.004+02:00

Registration is now open for the 4th Annual FACETS CodeJam meeting (http://neuralensemble.org/codejam4), which will take place June 22nd-24th, 2010 in Marseille, France.

The goal of the FACETS CodeJam workshops is to catalyze open-source, collaborative software development in computational and systems neuroscience and neuroinformatics, by bringing together researchers, students and engineers to share ideas, present their work, and write code together. The general format of the workshops is to dedicate the mornings to invited and contributed talks, leaving the afternoons free for discussions and code sprints.

For the 4th FACETS CodeJam, the main theme of the meeting will be workflows: what are the best practices for combining different tools (simulators, analysis tools, visualization tools, databases etc.) to ensure the efficient and reproducible flow of data and information from experiment conception to publication and archiving? Our invited speakers include:

• Dr Juliana Freire, who will talk about scientific data management, workflows and provenance, and give a demonstration of the VisTrails system.

• Dr Hugo Cornelis, who will talk about simulation project workflows in the GENESIS 3 simulator, and give a GENESIS 3 demonstration.

• Dr Gael Varoquaux, a primary contributor to the MayaVI 3D visualization tool for Python, will talk about analysing and modelling spontaneous brain activity in neuroimaging with
Python.

We invite contributions on any topic related to software in neuroscience, but especially on topics related to the main theme - if you think you have a good system for managing your workflow, please come and share it with us. If you have ideas for organising code sprints, whether a feature that you would like to see added to an existing tool or an idea for new software, please also let us know.

The meeting is being organised by Andrew Davison, Abigail Morrison, Eilif Muller and Laurent Perrinet.

Registration & Further Information
==================================

The registration deadline in 4 June 2010, and is limited to 40 participants.

Please consult the meeting website at

http://neuralensemble.org/codejam4

for registration and further information.

Tracking computational experiments with Sumatra

2010-04-06T16:09:00.002+02:00

“I thought I used the same parameters but I’m getting different results”

“I can’t remember which version of the code I used to generate ﬁgure 6”

“The new student wants to reuse that model I published three years ago but he can’t reproduce the ﬁgures”

“It worked yesterday”

“Why did I do that?”

We would like to announce the release of version 0.1 of Sumatra, a tool for tracking computational experiments and analyses so as to be able to easily replicate them at a later date.

Replication of computational experiments or analyses ought to be easy, given that computers don't suffer from the problems of inter-subject and trial-to-trial variability that make reproduction of biological experiments so challenging. In general, however, it is not easy, perhaps due to the complexity of our code and our computing environments, and the difficulty of capturing every essential piece of information needed to reproduce a computational experiment using existing tools such as spreadsheets, version control systems and paper notebooks.

The aim of Sumatra is to record as much as possible of the experimental context (software versions, parameters, dependencies, platform information, what files were produced, etc.) automatically, and make it easy to annotate the record with information that cannot be obtained automatically (why the simulation or analysis was performed, tags for later searching, etc.).

Given the large differences in the workflows of different researchers (command line, GUI, batch-jobs (e.g. in supercomputer environments), or any combination of these for different components (simulation, analysis, graphing, etc.) and phases of a project), it is difficult to provide a one-tool-fits-all solution, therefore Sumatra provides the core functionality as a Python package on top of which various different interfaces can be built.

Sumatra currently provides a command-line interface and a rudimentary web interface; we hope that people will also be interested in incorporating Sumatra's functionality within their own tools.

Sumatra 0.1 may be downloaded from the INCF Software Center or from PyPI.

For more information and documentation, check out https://neuralensemble.org/trac/sumatra/.

PyNN 0.6.0 released

2010-02-14T14:27:00.003+01:00

PyNN 0.6.0 is available for download from the INCF Software Center or from PyPI.

Changes

There have been three major changes to the API in this version.
Spikes, membrane potential and synaptic conductances can now be saved to file in various binary formats. To do this, pass a PyNN File object to Population.print_X(), instead of a filename. There are various types of PyNN File object, defined in the recording.files module, e.g., StandardTextFile, PickleFile, NumpyBinaryFile, HDF5ArrayFile.
Added a reset() function and made the behaviour of setup() consistent across simulators. reset() sets the simulation time to zero and sets membrane potentials to their initial values, but does not change the network structure. setup() destroys any previously defined network.
The possibility of expressing distance-dependent weights and delays was extended to the AllToAllConnector and FixedProbabilityConnector classes. To reduce the number of arguments to the constructors, the arguments affecting the spatial topology (periodic boundary conditions, etc.) were moved to a new Space class, so that only a single Space instance need be passed to the Connector constructor.

What is PyNN?

PyNN (pronounced 'pine' ) is a simulator-independent language for building neuronal network models.

PyNN is also being used as a user-friendly interface to neuromorphic hardware systems.

The code is released under the CeCILL licence (GPL-compatible).

For an in-depth explanation of the motivations behind PyNN and the guiding principles behind its design, see this article in Frontiers in Neuroinformatics. For a briefer overview, see this recent article in the Neuromorphic Engineer.

3rd INCF Congress of Neuroinformatics

2010-02-04T13:46:00.004+01:00

The 3rd INCF Congress of Neuroinformatics will take place in Kobe, Japan, from 30th August - 1st September 2010.

I'm particularly looking forward to the keynotes from Upi Bhalla ("Multiscale models of the synapse: a self-modifying memory machine") and Colin Ingram ("Working in the clouds: creating an e-science collaborative environment for neurophysiology"), and to the workshop on model description languages.

Abstract submission (for posters and demos) is open until 21st April. Hopefully I'll be able to present our Django-based framework for neuroscience databases.

NE.O welcomes The Brian Simulator

2010-01-10T21:07:00.002+01:00

We here at Neural Ensemble are proud to offer Trac/Subversion hosting to yet another excellent open-source Neuroscience project, The Brian Simulator:

"Brian is a simulator for spiking neural networks available on almost all platforms. The motivation for this project is that a simulator should not only save the time of processors, but also the time of scientists.

Brian is easy to learn and use, highly flexible and easily extensible. The Brian package itself and simulations using it are all written in the Python programming language."

The new trac page for Brian can be found here. Please join us in welcoming The Brian Simulator to our community, and making their stay with us a pleasant and fruitful one.

Slides from FACETS CodeJam #3

2009-11-03T10:57:00.002+01:00

The slides from most of the talks at the 3rd FACETS CodeJam workshop are now online.

The CodeJam workshops are focused on collaborative software development in neuroscience, particularly computational neuroscience, with mornings devoted to talks on recent developments and useful tools, and afternoons to code sprints.

This year we had the pleasure of listening to talks on speeding up Python using Cython, from Stefan Behnel, parallel processing on GPUs using PyOpenCL, from Andreas Klöckner, parallel processing with mpi4py from Eilif Muller, together with sessions on neuroscience data analysis using NeuroTools, OpenElectrophy and FIND, on reproducible research in computational neuroscience, on simulator technologies including NEST, NEURON, PCSIM, PyNN and MUSIC, and on neuromorphic hardware.

Notes on the code sprints will be posted later. Comments and some discussion of the talks can be found on FriendFeed.

FACETS CodeJam #3 Registration deadline approaching

2009-09-03T18:43:00.002+02:00

If you haven't yet registered for the 3rd Annual FACETS CodeJam, please visit
http://neuralensemble.org/codejam3 for more information on the meeting, and instructions for registering.

In short, The 3rd FACETS CodeJam will be held Oct 7-9, 2009 in Freiburg, Germany.
The FACETS CodeJam workshop is a FACETS sponsored meeting which is open to the public, and has established itself as a productive forum where various developers in the field of Neuroscience can get together, exchange ideas, plan future directions, and write code, with a hint of Python. It is the meeting where neuralensemble.org got started, and promises to be alot of fun again this year! Looking forward to meeting you there!

CodeNode - interactive online programming notebook

2009-09-02T16:20:00.002+02:00

Just came across this today (via). CodeNode is a tool that lets you program interactively in your browser using Python or Sage, with an interface something like a Mathematica notebook. You can organize your code into multiple notebooks and folders.

I don't really see this as a replacement for an IDE, but it might be a very nice tool for collaborative code writing (e.g. during code sprints), for working when travelling and away from your main development machine, and for literate programming.

The nearest equivalent I can think of is Bespin, although I think that's just an online code editor, it doesn't let you run the code.

It might be nice to run a CodeNode instance at NeuralEnsemble, although it would probably be best on a separate server: I imagine you could quickly bring a server to its knees if you have many users at once, or large data sets. What do you think?

NE.O Job Listings

2009-08-11T19:54:00.002+02:00

A "Jobs" tab has just been added to the neuralensemble.org navigation side-panel, listing jobs which may be of interest to the community. Kicking it off are two excellent opportunities for budding researchers in Europe or the US, with application deadlines soon! This is a listing for third-party job adverts, so please feel free to submit to admin@neuralensemble.org.

PyNN 0.5.0 released

2009-06-09T15:48:00.010+02:00

PyNN 0.5.0 is available for download from NeuralEnsemble.org, the INCF Software Center or PyPI.

Changes

There have been rather few changes to the API in this version, which has focused rather on improving the simulator interfaces and on an internal code-reorganization which aims to make PyNN easier to test, maintain and extend.

Principal API changes:

Removed the 'string' connection methods from the Projection constructor.
The method argument now must be a Connector object, not a string.
Can now record synaptic conductances.
Can now access weights and delays of individual connections one-at-a-time within a Projection through Connection objects.
Added an interface for injecting arbitrary time-varying currents into cells.
Added get_v() and get_gsyn() methods to the Population class, enabling membrane potential and synaptic conductances to be read directly into memory,rather than saved to file.

Improvements to simulator back-ends:

Implemented an interface for the Brian simulator.
Re-implementated the interface to NEURON, to use the new functionality in v7.0.
Removed support for version 1 of NEST. The module for NEST v2 is now simply called pyNN.nest.
The PCSIM implementation is now more complete, and more compatible with the other back-ends.
Behind-the-scenes refactoring to implement the API in terms of a small number of low-level, simulator-specific operations. This reduces redundancy between simulator modules, and makes it easier to extend PyNN, since if new functionality uses the low-level operations, it only needs to be written once, not once for each simulator.

What is PyNN?

PyNN (pronounced 'pine' ) is a simulator-independent language for building neuronal network models.

The API has two parts, a low-level, procedural API (functions create(), connect(), set(), record(), record_v()), and a high-level, object-oriented API (classes Population and Projection, which have methods like set(), record(), setWeights(), etc.)

The low-level API is good for small networks, and perhaps gives more flexibility. The high-level API is good for hiding the details and the book-keeping, allowing you to concentrate on the overall structure of your model.

The other thing that is required to write a model once and run it on multiple simulators is standard cell and synapse models. PyNN translates standard cell-model names and parameter names into simulator-specific names, e.g. standard model IF_curr_alpha is iaf_neuron in NEST and StandardIF in NEURON, while SpikeSourcePoisson is a poisson_generator in NEST and a NetStim in NEURON.

PyNN is a work in progress, but is already being used for several large-scale simulation projects.

The code is released under the CeCILL licence.

For full details, see the users' guide and the API reference.

EuroScipy 2009 in Leipzig, Germany

2009-04-30T17:06:00.002+02:00

I just noticed today the EuroScipy 2009 will be held again in Leipzig this year. The deadline for abstract submission is today, but maybe they will extend that by a week.

CNS workshop “Python in Neuroscience”: call for participation

2009-04-01T01:40:00.003+02:00

We wish to announce the workshop “Python in Neuroscience”, to be held July 22nd-23rd, 2009 at the CNS’09 conference in Berlin, made possible by generous support from the European Union under the Bio-inspired Intelligent Information Systems program, project reference IST-2004-15879 (FACETS,
www.facets-project.org), and by the Bernstein Center for Computational Neuroscience (BCCN), Albert-Ludwigs-University Freiburg, Germany (www.bccn.uni-freiburg.de).

Python is rapidly becoming the de facto standard language for systems integration. Python has a large user and developer-base external to the neuroscience community, and a vast module library that facilitates rapid and maintainable development of complex and intricate systems. In this
workshop, we highlight efforts to develop Python modules for the domain of neuroscience software and neuroinformatics. Moreover, we seek to provide a representative overview of existing mature Python modules for neuroscience and neuroinformatics, to demonstrate a critical mass and show that Python is an appropriate choice of interpreter interface for future neuroscience software development.

There will be tutorial & demo sessions where visitors with laptops can install and get introduced and acquainted with Python and the various software. A preliminary program can be found on the CNS web site: http://www.cnsorg.org/2009/workshops.shtml

The workshop will include several sessions of lightning talks (http://en.wikipedia.org/wiki/Lightning_Talk), which are 5 minutes talks on any subject relevant to Python for neuroscience. Please send us an abstract proposal by email (romain.brette@ens.fr) if you are interested in giving such a talk. It could be about your own personal software contribution or about your experience with an existing Python module or tool that you think could be relevant for neuroscience. We will select a limited number of abstracts from the submissions. The deadline for
submission is April 30th.

We look forward to seeing you in Berlin.

Eilif Muller, Jens Kremkow, Andrew Davison and Romain Brette

Advanced Scientific Programming in Python G-Node Summer School

2009-03-26T12:39:00.003+01:00

When: August 31st, 2009 - September 4th, 2009.
Where: Berlin, Germany.

Many scientists spend much of their time writing, debugging, and
maintaining software. But while techniques for doing this efficiently
have been developed, only few scientists actually use them. As a
result, they spend far too much time writing deficient code and
reinventing the wheel instead of doing research. In this course we
present a selection of advanced programming techniques with
theoretical lectures and practical exercises tailored to the needs of
the programming scientist. To spice up theory and foster our new
skills in a real-world programming project, we will team up to develop
an entertaining scientific computer game.

We will use the Python programming language for the entire
course. With a large collection of open-source scientific modules and
all features of a full-fledged programming language, Python is rapidly
gaining popularity in the neuroscience community. It enables the
scientist to quickly develop powerful, efficient, and structured
software and is becoming an essential tool for scientific computing.

The summer school is targeted at Post-docs and PhD students from all
areas of neuroscience. Substantial proficiency in Python or in
another language (e.g. Java, C/C++, MATLAB, Mathematica) is absolutely
required. An optional, one-day pre-course is offered to participants
without Python experience to familiarize with the language.

Preliminary Program
-------------------
Day 0 (Mon Aug 31) -- [Optional] Dive into Python

Day 1 (Tue Sep 1) -- Software Carpentry
- Documenting code and using version control
- Test-driven development & unit testing
- Debugging, profiling and benchmarking techniques
- Object-oriented programming, design patterns and Extreme Programming

Day 2 (Wed Sep 2) -- Scientific Tools for Python
- NumPy, SciPy, Matplotlib, IPython
- Neuroscience libraries
- Programming project in the afternoon

Day 3 (Thu Sep 3) -- Parallelization
- Python multiprocessing for SMP machines
- Distributed parallelization for cluster computing
- Programming project in the afternoon

Day 4 (Fri Sep 4) -- Practical Software Development
- Software design
- Efficient programming in teams
- Quality Assurance
- Finalizing the programming project

Applications
------------
Applications should be sent before May 31st, 2009 to
pythonsummerschool@bccnberlin.de. No fee is charged but participants
should take care of travel, living, and accommodation expenses.

Applications should include full contact information (name,
affiliation, email & phone), a short CV and a short statement
addressing the following questions (maximum 500 words):
- What is your educational background?
- What experience do you have in programming?
- Why do you think "Advanced Scientific Programming in Python" is an
appropriate course for your skill profile?

Candidates will be selected based on their profile. Places are
limited: early application is recommended.

Faculty
-------
Pietro Berkes, Volen Center for Complex Systems, Brandeis University, USA
Jens Kremkow, Bernstein Center for Computational Neuroscience Freiburg, Germany
Eilif Muller, Laboratory of Computational Neuroscience, Ecole Polytechnique Fédérale de Lausanne, Switzerland
Michael Schmuker, Neurobiology, Freie Universität Berlin, Germany
Bartosz Telenczuk, Charité Universitätsmedizin Berlin, Germany
Niko Wilbert, Institute for Theoretical Biology, Humboldt-Universität zu Berlin, Germany
Tiziano Zito, Bernstein Center for Computational Neuroscience Berlin, Germany

Organized by Michael Schmuker and Tiziano Zito for the German
Neuroinformatics Node of the INCF.

Website: http://www.g-node.org/Teaching
Contact: python-summerschool@bccn-berlin.de

2nd INCF Congress of Neuroinformatics

2009-02-23T16:36:00.004+01:00

The 2nd INCF Congress of Neuroinformatics will take place in Pilsen, Czech Republic, from September 6th-8th 2009.

Last year's meeting in Stockholm was excellent - check out the videos of the keynote talks.

The deadline for abstract submission is April 17th.

When will NumPy and SciPy move to Python 3.0?

2009-02-05T20:57:00.003+01:00

http://jarrodmillman.blogspot.com/2009/01/when-will-numpy-and-scipy-migrate-to.html

Python 2.6 by March 2009

Python 3.0 by mid-to-late 2010?

Once Numpy and Scipy hit 3.0, we can port NeuroTools: this shouldn't be a very difficult task, since NeuroTools is pure Python, with no C-extensions. Porting PyNN depends on the simulator backends - NEURON, NEST, PCSIM, Brian - being ported, but again, PyNN itself should be a straightforward task.

Hot off the press: PyNN, PyNEST, NEURON+Python, Brian

2009-01-06T09:57:00.004+01:00

Hot off the press!

Several new publications of interest for NeuralEnsemblers to appear in the Frontiers in Neuroinformatics special section "Python in Neuroscience" are already available in provisional form at

http://www.frontiersin.org/neuroinformatics/specialtopics/8/

including but not limited papers on large-scale simulation technologies like PyNN, PyNEST, NEURON+Python, and Brian:

Hines M, Davison AP and Muller E (2009) NEURON and Python. Front. Neuroinform. doi:10.3389/neuro.11.013.2009

http://www.frontiersin.org/neuroinformatics/paper/10.3389/neuro.11/013.2009/

Eppler JM, Helias M, Muller E, Diesmann M and Gewaltig M (2008) PyNEST: A convenient interface to the NEST simulator. Front. Neuroinform. doi:10.3389/neuro.11.012.2008

http://www.frontiersin.org/neuroinformatics/paper/10.3389/neuro.11/012.2008/

Davison AP, Brüderle D, Eppler JM, Kremkow J, Muller E, Pecevski DA, Perrinet L and Yger P (2008) PyNN: a common interface for neuronal network simulators. Front. Neuroinform. doi:10.3389/neuro.11.011.2008

http://www.frontiersin.org/neuroinformatics/paper/10.3389/neuro.11/011.2008/

Goodman D and Brette R (2008) Brian: a simulator for spiking neural networks in Python. Front. Neuroinform. (2008) 2:5. doi:10.3389/neuro.11.005.2008

http://www.frontiersin.org/neuroinformatics/paper/10.3389/neuro.11/005.2008/

Python 3.0 final released

2008-12-04T12:11:00.002+01:00

"Python 3.0 (a.k.a. "Python 3000" or "Py3k") is a new version of the language that is incompatible with the 2.x line of releases. The language is mostly the same, but many details, especially how built-in objects like dictionaries and strings work, have changed considerably, and a lot of deprecated features have finally been removed. Also, the standard library has been reorganized in a few prominent places."

http://www.python.org/download/releases/3.0/

For what's new, go here.

Given the extent of the syntax changes, it may be a while before Python 3.0 is officially supported by NeuralEnsemble projects.

NeuroTools 0.1 (Asynchronous Astrocyte) released

2008-11-13T14:16:00.006+01:00

NeuroTools is a Python package for analysis, visualization and management of real and simulated neuroscience data, built on top of numpy and matplotlib.

Inspired by Ubuntu, the first release is code-named "Asynchronous Astrocyte". Suggestions for names for future releases are welcome!

It is available for download from:

http://software.incf.org/software/neurotools/home/download

or just

easy_install NeuroTools

The NeuroTools homepage, with full documentation, is at:

http://neuralensemble.org/NeuroTools

NeuroTools Live Demo @ INCF Booth, SfN 2008. (Nov 16; 9:30-12:30)

2008-11-12T10:53:00.004+01:00

NeuroTools Live Demo @ SfN 2008
===============================

Time: Nov 16; 9:30-12:30
Location: INCF Booth #3227

NeuroTools: Analysis, visualization and management of real and
simulated neuroscience data.

Jens Kremkow, Thierry Brizzi, Daniel Bruederle, Andrew Davison,
Eilif Muller, Laurent Perrinet, Michael Schmuker, Pierre Yger

http://neuralensemble.org/NeuroTools
http://www.incf.org

BCCN/FACETS Student Workshop: Using Python for Computational Neuroscience

2008-06-13T18:53:00.000+02:00

Thanks to Jens Kremkow, Jochen Eppler, Bernd Wiebelt, the BCCN Freiburg staff and all the motivated students and lecturers for making the first BCCN/FACETS Student Workshop on Using Python for Computational Neuroscience a great success! Lecture material can be found here.

PyNN 0.4.1 released

2008-06-12T13:39:00.000+02:00

Cookbook launched

2008-06-09T18:44:00.000+02:00

Thanks to Dan Goodman and the Neural Ensemble googlegroup for the impetus, a cookbook for computational neuroscience recipies can now be found at http://www.neuralensemble.org/cookbook.

Call for Contributions - Python in Neuroscience Special Section

2008-06-03T13:41:00.000+02:00

CALL FOR CONTRIBUTIONS

Special Section: "Python in Neuroscience"
Journal: Frontiers in Neuroinformatics [www.frontiersin.org/neuroinformatics]

Associate Editor:
Rolf Kötter (Radboud University Medical Centre Nijmegen, Netherlands)

Guest Editors:

James A. Bednar (University of Edinburgh, UK)
Andrew Davison (UNIC, CNRS, France)
Markus Diesmann (RIKEN Brain Science Institute, Japan)
Marc-Oliver Gewaltig (Honda Research Institute Europe GmbH, Germany)
Michael Hines (Yale University, USA)
Eilif Muller (LCN-EPFL, Switzerland)

Important Dates:

Abstract/outline submission deadline: June 14th, 2008.
Invitations for full paper submissions sent by June 21st, 2008.
Invited full paper submission deadline: September 14th, 2008.

Special Section Abstract:

Python is rapidly becoming the de facto standard language for systems
integration. Python has a large user and developer-base external to
the neuroscience community, and a vast module library that facilitates
rapid and maintainable development of complex and intricate systems.

In this special section, we highlight recent efforts to develop Python
modules for the domain of neuroscience software and neuroinformatics:

- simulators and simulator interfaces
- data collection and analysis
- sharing, re-use, storage and databasing of models and data
- stimulus generation
- parameter search and optimization
- visualization
- VLSI hardware interfacing
- ...

Moreover, we seek to provide a representative overview of existing
mature Python modules for neuroscience and neuroinformatics, to
demonstrate a critical mass and show that Python is an appropriate
choice of interpreter interface for future neuroscience software
development.

Submission Procedure:

Researchers and practitioners are invited to submit on or before June
14th, 2008 a max. 1 page abstract/outline of work related to the focus
of the special section to eilif.mueller@epfl.ch, CC'd to rk@cns.umcn.nl
for consideration for inclusion as an elaborated full article in the
special section.

Please include a provisional title, a full author list, and format the
subject of your email as follows: "[python SI] outline - Your Name".

Authors will be notified whether their contribution has been accepted
by June 21st, 2008.

Full Article Information:

* Full articles will be solicited by invitation only, based on the
abstracts/outlines we receive by June 14th, 2008.

* The deadline for submission of invited full articles will be
September 14th, 2008.

* Article formatting will be as for standard Frontiers "Original
Research Articles". Guidelines and instructions for their preparation
can be found at
http://frontiersin.org/authorinstructions#manuscriptGuidelines.

* General author instructions for Frontiers in Neuroinformatics can be
found at http://frontiersin.org/authorinstructions/.

* Frontiers in Neuroinformatics is an open access journal, following a
pay-for-publication model. Details of the publication fees can be found
at http://www.frontiersin.org/publicationfees/.

* Further details will be provided to authors of accepted abstracts by
June 21st, 2008.