NE.O Job Listings

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

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. 

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

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.

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

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

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

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

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?

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.