1
$\begingroup$

I'd like to build a spiking neural network and deploy it in neuromorphic hardware. I'd like to modify the number of neurons of a population at runtime, depending on a condition.

Frameworks like Nengo don't seem to support such modifications at runtime. Is there any workaround that could be used? Does any other framework support runtime modifications on the number of neurons (and other properties)?

Improve this question
$\endgroup$

1 Answer 1

Reset to default
1
$\begingroup$

The challenge you've identified is a notable limitation in most existing neuromorphic computing frameworks, including Nengo. Generally, these frameworks are designed for static network configurations, meaning the number of neurons, connections, and other properties are fixed at compile time.

Workarounds in Nengo:

  • Multiple Models: One option could be to pre-compile multiple models with different numbers of neurons, and switch between them at runtime depending on your condition. This approach would not be seamless but could offer a way to adapt to changing conditions.

  • Dynamic Nodes: Nengo allows the inclusion of Python functions via nodes that can be part of your model. You could potentially write a custom node that mimics the behavior of having a different number of neurons, though this would be quite involved and wouldn't leverage the underlying neuromorphic hardware.

  • Parameter Modulation: While not changing the number of neurons, you could potentially change their behavior dynamically by modulating other parameters like firing rates, synaptic weights, etc., based on your condition.

Other Frameworks:

  • TensorFlow / PyTorch for Spiking Neural Networks: These general-purpose machine learning libraries are increasingly adding support for spiking neural networks and can offer more flexibility in dynamically changing the network configuration. However, deploying them on specialized neuromorphic hardware could be challenging.

  • Is there specialized hardware, specifically designed for spiking neural networks? Changing the number of neurons on-the-fly may not be straightforward though.

  • Custom Solution: Building a custom solution tailored to your specific needs could be the most flexible option, though also the most time-consuming. This would involve developing your spiking neural network model at a lower level, perhaps even directly interfacing with the neuromorphic hardware if possible.

While there are no straightforward solutions, the above options could provide a viable path forward depending on your specific requirements and constraints.

Improve this answer
$\endgroup$
3
  • 1
    $\begingroup$ Hello, thank you so much for the detailed reply. I was thinking of either trying the synaptic weight modification in Nengo, or trying TensorFlow / PyTorch for Spiking Neural Networks. Do you have any resources on how to change synaptic weights at runtime in Nengo, or the network configuration in Tensorflow for SNNs? $\endgroup$
    – elli al
    Commented Oct 15, 2023 at 15:08
  • $\begingroup$ For Nengo: Would nengo.Node to create a function that modifies synaptic weights based on some condition at runtime work? Look into Nengo's documentation on nengo.Connection and nengo.Node for better insights. $\endgroup$
    – Roel Van de Paar
    Commented Oct 15, 2023 at 21:28
  • $\begingroup$ For TensorFlow/PyTorch: Explore the Norse library which extends PyTorch for SNNs (github.com/norse/norse). In TensorFlow, you may find the tf.keras built-in functionalities for SNNs useful. Additionally, look into the BindsNET library (github.com/BindsNET/bindsnet) which provides a bridge between TensorFlow and PyTorch for SNNs. $\endgroup$
    – Roel Van de Paar
    Commented Oct 15, 2023 at 21:29

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .