Neuronify documentation
Neuronify is an educational app for studying neural networks. The engine is based on an integrate-and-fire model. This documentation provides information about how you can obtain the program and how it is structured.
Getting started
Neuronify can be downloaded for multiple platforms. Mobile versions of Neuronify will be available soon in Google Play and Apple App Store.
For Linux, Mac and Windows users, Neuronify can be downloaded here:
For Linux users, the application must be built from source.
A short set of exercises that will help you get started can be found here:
Neuroscience theory
Neuronify is based on an integrate-and-fire model of neurons. To understand this model, we have outlined some basic theory of computational neuroscience in the following documents:
- General neuroscience
- Integrate-and-fire model
- Adaptive neurons
- Poisson Distributed Spike Generator
- Receptive field
Development and technical details
Neuronify is written in C++ and QML using the Qt Framework. The GUI is written in QML, while the core parts of the engine that performs the time integration of the neural network is written in C++. However, several of the network elements and neurons used in Neuronify are written as QML objects.
Core
The core of Neuronify consists of a small set of GUI and engine classes. At the heart of the GUI is the Neuronify QML type that organizes all the visual items and the holds a reference to GraphEngine. Each item in the network is controlled by the GraphEngine. This is a C++ class that holds a list of nodes and their connections through edges.
The nodes of the network are split into three parts: NodeBase, NodeEngine and Node. The former two are C++ classes, while the latter is a QML type.
In principle, NodeBase and Node could have been the one and same C++ class. The reason they are split up is because some features of Node are defined in QML, such as a MouseArea with dragging. Since NodeEngine, Edge and GraphEngine are C++ classes, they cannot have type-safe pointers to a Node object because this will be defined first once the application has started. That is why they instead refer to the C++ type NodeBase. In the future, this may change and all features of Node may be incorporated in a C++ class.
Basic connection between two nodes | |
The core engine of Neuronify | |
Basic functionality of all nodes | |
Used to perform operations in for NodeBase |
Neurons
Neurons are defined by subclassing the Neuron QML Type and adding a NeuronEngine. To change the behavior of a NeuronEngine, Current objects may be added as children to it. The NeuronEngine will iterate all its children and sum their currents.
Produces a current that drives the voltage towards the membrane potential and increases each time the neuron fires | |
Defines the currents used by NeuronEngine | |
Common engine used by most neurons | |
Defines a current that drives the NeuronEngine towards the defined resting membrane potential | |
Common engine used RatePlot |
Generators
Generators are used to feed the network with automatic input.
An alternating current generator which can suply input to neurons | |
A direct current generator which can suply input to neurons | |
An spike generator which can supply input spikes to neurons | |
An spike generator which can supply input spikes to neurons |
Meters
Meters can be used to measure the state of the neurons.
Shows firing times of neurons | |
Reads the firing rate of the neurons and shows a trace plot | |
A speaker that emits a sound whenever a connected neuron fires | |
Reads the voltage of the neurons and shows a trace plot |
Sensors
Sensors are used to get information from the outside world to the app.
Creates different kernel types | |
Visual sensor that can be connected to neurons to generate activity based on the receptive field of the sensor and the visual stimuli captured by the camera | |
Calculates the firing rate of a neuron based on the stimulus and the receptive field type | |
Paints the camera frame and the spatial receptive field function | |
Registers touch (or mouse) events and converts them into a current that may be injected into neurons | |
Converts the camera frame to a gray-scale image |
Tools
The following classes are used as tools to aid other types.
Helper class used for reading and writing files from QML |
Complete list of items
For a comprehensive list, see All Classes and Neuronify QML Types
Future development
Neuronify is in active development. Some target features that we wish to include in the future are:
- Long-term learning schemes such as long-term potentiation.
- User-generated neurons and items (written as QML plugins).
- Possibility to share saved simulations.
- Exercises built into the app for easier implementation in courses.
- Positioning features to mimic grid cells.