Brian2Lava

[andrewlehr]

We want to interface Brian2 with Lava to facilitate deployment of brain-inspired algorithms on Lava-supported neuromorphic hardware and emulator backends.

The differential equation based model definition in Brian2 makes model exploration and prototyping very convenient. Neuron models and synapses can be flexibly defined, connectivity structures and plasticity rules equally so.

Given the direction of Loihi2 for general neuron models and three factor plasticity rules, enabling ODE based model design would be a great feature.

Beyond the interface, we want to contribute to the Lava framework to allow users and developers to program in Brian2 or Lava and deploy their models on either neuromorphic hardware or CPUs/GPUs. We have model conversion and network design tools in mind to facilitate this process.

Interested in collaborating, contributing, or have general ideas and desired features/capabilities? Let us know!

UPDATE:
See the Brian2Lava website [1] and Gitlab repository [2] for more information.

[1] https://brian2lava.gitlab.io/
[2] https://gitlab.com/brian2lava/brian2lava

[Tobias-Fischer]

Hey @andrewlehr - this sounds super exciting, and I'd be keen to contribute in some way. I'm not sure whether you had the chance of attending my short talk at the Lava Developer Forum - I think that setting up a model currently in Lava seems a little complex; Brian2's API seems a lot easier to use. We'd (with @Somayeh-h) love to deploy our models on Loihi though, so a conversion tool would be amazing.

Would be great if you could share some more of your thoughts.

Best, Tobi

[awintel]

Would you mind sharing what feels way too complex in the main Lava API? Perhaps there's something to improve at this level as well. Is it just that you are seeking an ability to specify ODEs?
Thanks

[andrewlehr]

Hey @Tobias-Fischer, awesome to hear that you are keen to contribute! I saw your talk and think it would be great to have your ideas flow into this project. Do you have concrete ideas about how you want to contribute and/or what features you would like to see? If not yet, no worries! Of course also feel free to email me: andrew.lehr[at]phys.uni-goettingen.de.

Briefly, we want to connect Brian2 with Lava so that models defined in Brian2 can be easily deployed on CPU/GPU-based neuromorphic emulators (e.g. for Loihi1, Loihi2) and on neuromorphic hardware (e.g. Loihi1, Loihi2). This will entail developing an API that can make Lava processes and process models out of Brian2 models. We hope this will enable efficient prototyping by allowing flexible model definition and parameter search and then direct deployment to the chip once the appropriate model architecture is found.

Beyond this, it would likely be useful to have a new front-end that has the best aspects of existing frameworks (Brian2 being just one of these) tailored to neuromorphic development. This will require ODE parsing, numerical integration methods, smart connectivity definition and representation, built on top of the Lava architecture. Perhaps it is too early to know exactly what this will look like, but it would be great to start collecting what it should and shouldn't do. Probably there will be a number of different front ends tailored to different applications (e.g. lava-dnf, lava-dl, ...) and this will be just one way of doing it.

Best,
Andrew

[awintel]

Would be great to see a mock code example that shows the usage from model definition to execution and perhaps post processing. The code does not have to be functional yet but just illustrate the "look and feel" from the highest level.
It would also be good to show how models defined through this interface can connect to other models build perhaps in "pure" Lava.

People can then comment on the UI and give feedback.

[andrewlehr]

Thanks Andreas, this is a great idea on how to get feedback on the UI early on. Until we have something, I will point to some simple examples of how to define things in the Brian2Loihi emulator. Note though that there the neuron and synapse model are constrained by Loihi1, so the flexible ODE-based definition is not possible and this is all hidden in the LoihiNeuronGroup and LoihiSynapses.

[awintel]

Yeah. That looks pretty much like NxSDK in terms of Neuron and Synapse Groups.

When you are ready. You could either post some mock code here or in a jupyter notebook to illustrate the full Brian2Lava API.
That's probably the best thing to do before launching any new implementation work.

Thanks

[sagacitysite]

I quickly want to share a mockup with the community of how we currently imagine the principles of the Brian2Lava package. If you have any further ideas, questions, remarks, etc. just leave a comment :)

1. Defining a network

First we define a network in Brian as usual with two additional lines. First, we need to import the brian2lava package and second, we need to set a device using the Brian function set_device. Within this function, we can also choose the hardware backend (e.g. CPU, Loihi1, Loihi2, etc.). The following shows a reduced example.

from brian2 import *
import brian2lava

set_device('lava', use='Loihi2', debug=True)

# ...

eqs = '''
dv/dt  = (ge+gi-(v-El))/taum : volt (unless refractory)
dge/dt = -ge/taue : volt
dgi/dt = -gi/taui : volt
'''

P = NeuronGroup(4000, eqs, threshold='v>Vt', reset='v = Vr',
                refractory=5*ms, method='exact')

# ...

Ce = Synapses(P, P, on_pre='ge += we')
Ci = Synapses(P, P, on_pre='gi += wi')
Ce.connect('i<3200', p=0.02)
Ci.connect('i>=3200', p=0.02)

s_mon = SpikeMonitor(P)

run(1 * second)

2. Numerical formulation of the ODE

The ODE, defining a neuron model, can be chosen arbitrarily. Here a simple example (note: different from above).

# Differential equation
eqs = '''
dv/dt = (v0-v)/tau : volt (unless refractory)
v0 : volt
'''

Brian has aldready the capability to solve this equation and gives us a numerical solution, called abstract code.

# Abstract code (exponential euler)
not_refractory = 1*((t - lastspike) > 0.005000)
_BA_v = -v0
_v = -_BA_v + (_BA_v + v)*exp(-dt*not_refractory/tau)
v = _v

This code forms the basis to create a process and process model in Lava.

3. Process and process model

In pricinple we would like to use the template engine Jinja to dynamically generate processes (hardware independent) and process models (different for every hardware). A highly simplified example could look like this:

# Process model template using Jinja
{% for line in code_lines %}
{{line}}
{% endfor %}
_return_values, = _cond.nonzero()

In this example some code lines (coming from Brian) are filled into a process and process model to define the neuron model in Lava.

# Rendered process model
v = _array_neurongroup_v
_cond = v > 10 * mV
_return_values, = _cond.nonzero()

[sagacitysite]

• Yes, it is autogenerated. I don't know if it is efficient, but Brian uses vectorized expressions in principle (https://brian2.readthedocs.io/en/stable/advanced/functions.html), as long as numpy is used as code generator.
• How the code is generated to NcProcModels is currently internally under discussion. As soon as we have a better understanding of how NC models are defined in Lava, we will work out a more concrete solution and can then of course directly share more details about it. I will make a note and as soon as we have more details available, I will post it here.

[awintel]

Conceptually, what you'll do in an NcProcModel will be similar to what you did in the past with NxNet. Just different syntax. You are effectively building a graph of axons, synapses and neurons while configuring their properties.
So you might be unblocked already to plan ahead until the final API is ready.

[sagacitysite]

Ok, cool, that's then clear to me. But how is the neuron model itself defined (in case of Loihi 2)? Just as a string (similar to a learning rule)?

[awintel]

Yes, the assembly language is definitely new and we will provide you with these details soon.

If your ambition is to write a true compiler from generic high level Python to Loihi 2's assembly language then I highly suggest to collaborate on this and not even treat this as a Brian2Lava component because this is a quite universal problem.
If you however, only want to target specific parameterized programs then it's similar to NxNet just with more types of parameters to chose from.

[sagacitysite]

Thanks, that was very clear!

So we could either translate the abstract code from Brian to NxNet-like parameters or bring it to Loihi's assembly language directly with an own compiler. At the moment I would favor to try to translate it to parameters and use the NxNet-like library. I think for this approach we could make use of our neuron model fitter (which we have developed to fit neuron models to Loihi parameters). The advantage of this approach would be that it would work for both Loihi 1 and Loihi 2, we already have a lot of experience using the NxSDK and can probably reach a first version faster. But it could, in principle, be cleaner to compile it directly and I agree that this is probably not a Brian2Lava component. I think we should still keep it in mind. Especially if Brian2Lava gets some popularity, it could be a nice improvement for later versions.

However, thanks again for these information. I think with this we can already prepare more details about the implementation of NcProcModels!

[lyanausa]

Brian2 model with conductance-based synapses on Loihi2 backend using brian2lava package

Hi all,

I would like to know if the hardware backend for Loihi2 is now included in the brian2lava package. I am currently working on running a conductance-based LIF neuron model on Loihi2, but now I only have the Brian2 model. It seems that I could use the brian2lava package to run the Brian2 model on the Loihi2 backend. Is that correct?

[jlubo]

Hi lyanausa!

The latest Brian2Lava release (v1.0.0-alpha.3) does not yet include the Loihi 2 hardware backend, but the next version, which we want to have released by the end of the month, will support this. You will be able to access it if you are an "Engaged Member" of the INRC. However, since there is no generic Lava-to-microcode API, we can at the moment only support pre-defined neuron models and the adaptation of their parameter values. First, there will be support for LIF neurons, and probably soon for different adaptive LIF neurons.

Nevertheless, if you'd like, we'll be happy to work together to implement your neuron model within Brian2Lava! Using the existing interface, this may save you a lot of time, and on the other hand it'll be a nice extension for the Brian2Lava package.

[lyanausa]

Hi @jlubo,

Thanks for the reply! I'd like to stay in the loop for the launch, because I think it would be still useful for my project. I am an INRC member, so I am excited to try it out once it's ready.
The neuron model that I am using is not a pre-defined neuron model in Lava (is that what you are referrring to?). This neuron uses time-varying conductances - similarly to conductance-based models - and spike-frequency adaptation. Since I am working in a limited timeframe, I will have to reside to custom-design models in lava and microcode. But I would be happy to discuss this further to see how I can speed up the process with the existing framework.

P.S. I also contacted you via email - with more detail about the model and the project- about a possible discussion and to see if somehow (a part of ) the framework can be implemented to save me time.

[jlubo]

What I meant is that for Loihi 2 use we'll have neuron models that are pre-defined by Brian2Lava (at first, only LIF, and soon, also adaptive LIF models). I guessed that your neuron model requires features beyond a common LIF, so that's why I said we'd have to implement it! We shall continue discussing that somewhere else :)