Dynamic Neural Fields
=====================

Introduction
------------

Dynamic Neural Fields (DNF) are neural attractor networks that generate
stabilized activity patterns in recurrently connected populations of neurons.
These activity patterns form the basis of neural representations, decision
making, working memory, and learning. DNFs are the fundamental
building block of `dynamic field theory <https://dynamicfieldtheory.org>`_
a mathematical and conceptual framework for modeling cognitive processes in
a closed behavioral loop.


*Voltage of a selective dynamic neural field tracking moving input*

.. image:: https://user-images.githubusercontent.com/5708333/135443996-7492b968-277a-4397-9b1c-597b7af4a699.gif
   :target: https://user-images.githubusercontent.com/5708333/135443996-7492b968-277a-4397-9b1c-597b7af4a699.gif
   :alt: 2D DNF tracking bias input

|

What is lava-dnf?
-----------------

lava-dnf is a library within the Lava software framework. The main building 
blocks in Lava are processes. lava-dnf provides
processes and other software infrastructure to build architectures composed of
DNFs. In particular, it provides functions that generate connectivity patterns
common to DNF architectures.

The primary focus of lava-dnf today is on robotic applications: sensing and
perception, motion control, behavioral organization, map formation, and
autonomous (continual) learning. Neuromorphic hardware provides significant
gains in both processing speed and energy efficiency compared to conventional
implementations of DNFs on a CPU or GPU (e.g., using
`cedar <https://cedar.ini.rub.de>`_ or `cosivina <https://github.com/cosivina>`_).


Key features
------------

Building DNF architectures

#. Based on spiking neurons
#. DNF dimensionality support for 0D, 1D, 2D, and 3D
#. Recurrent connectivity based on kernel functions
#. Forward connectivity to connect multiple DNFs
#. Structured input from spike generators

Running DNF architectures

#. On CPU (Python simulation)
#. On Loihi 2

Examples demonstrating basic DNF regimes and instabilities

#. Detection of input
#. Selection of input
#. Working memory of input
#. Relational networks


Example
-------

.. code-block:: python

    from lava.proc.lif.process import LIF
    from lava.lib.dnf.kernels.kernels import SelectiveKernel
    from lava.lib.dnf.connect.connect import connect
    from lava.lib.dnf.operations.operations import Convolution

    # Create a population of 20x20 spiking neurons.
    dnf = LIF(shape=(20, 20))

    # Create a selective kernel.
    kernel = SelectiveKernel(amp_exc=18, width_exc=[4, 4], global_inh=-15)

    # Apply the kernel to the population to create a DNF with a selective
    # regime.
    connect(dnf.s_out, dnf.a_in, [Convolution(kernel)])