^{1}

^{2}

^{1}

^{2}

^{*}

^{1}

^{2}

Edited by: Chris G. Antonopoulos, University of Essex, United Kingdom

Reviewed by: Daqing Guo, University of Electronic Science and Technology of China, China; Masanori Shimono, Kyoto University, Japan

This is an open-access article distributed under the terms of the Creative Commons Attribution License (CC BY). The use, distribution or reproduction in other forums is permitted, provided the original author(s) and the copyright owner(s) are credited and that the original publication in this journal is cited, in accordance with accepted academic practice. No use, distribution or reproduction is permitted which does not comply with these terms.

Connectivity and biophysical processes determine the functionality of neuronal networks. We, therefore, developed a real-time framework, called Neural Interactome^{1}^{,}^{2}

Modeling neuronal systems involves incorporating two modeling layers. The first fundamental layer is of neuronal connectivity (connectome). The layer on top of it is of biophysical processes of neural responses and interactions. In the recent years there has been significant progress in resolving and modeling both layers. Connectomes of several organisms and systems, such as the nematode

Being closer to the realistic neuronal system,

Here, we have taken a complementary approach. We focus on

In this paper, we focus on applying the framework to the nervous system of

The availability of near-complete connectome data along with experimental quantification of responses and interactions provided a computational basis for reconstructing both static and dynamic layers of

We first describe the main components of the Neural Interactome framework, and then continue to demonstrate its application to the nervous system of

The frontend of Neural Interactome is an interactive interface consisting of (i) neural stimulation/ablation interface, (ii) visualization of dynamics, (iii) control of simulation timescale, and (iv) review system.

Neural stimuli are controlled by stimulation panel located on the left side of the screen. The panel enslists and categorizes all neurons in the network into three group types (sensory, inter, motor). Each group type is given a characteristic color (sensory: blue, inter: green, motor: red). Each individual neuron on the panel is a clickable button with a scrollable bar, which allows setting amplitudes of constant stimulus, i.e., inject current to the neuron (of nA nano-ampere unit). The amplitude of the stimulus can be adjusted prior to running a simulation (as initial condition), or at any time during the simulation. When stimulus is being adjusted during the simulation, it effectively imitates “clamping” of neurons in the network. In addition, to allow for testing various structural configurations for the network, the panel is designed to support neural ablation of neurons. By clicking on a neuron while holding the shift key, the neuron is grayed-out in the interface. Such operation disconnects the neuron from all of its respective connections (both receiving and outgoing) in both synaptic and gap type and thus effectively removes it from the network. The ablation can also be undone (reinsertion) by repeating the operation of shift key + clicking on the ablated neuron. Similar to neural stimulation, both ablation and reinsertion can be performed prior and during network simulation.

Visualization of the _{edge(A, B)} = _{Syn(A → B)}, n_{Syn(B → A)}), where _{Syn(A→B)} is the number of synapses from neuron A to B.

Interactive interface for Neural Interactome. Left panel enlists all the neurons classified by type (sensory, inter and motor). Each neuron is a clickable button with a scroll option. Scrolling adjusts the magnitude of constant stimulus; shift + click ablates the neuron from the network. Right: Force-directed graph displays each neuron's membrane voltage (node color denotes the sign; radius denotes the magnitude) and connections between neurons (edges between each pair of nodes). At the bottom of the graph, time bar keeps track of visualized time point (dark gray), and of computed time by the backend neural integration (light gray).

Visualization and main functionalities of Neural Interactome.

In addition, we use force-directed graph algorithm to arrange the nodes and edges in optimal positions (Bostock et al.,

Neural activity is represented as an additional layer on top of the static connectivity graph. We find that optimal approach to visualize the two layers is to alter graph components (nodes and edges) according to neural activity. This creates a “breathing graph” which represents network activity and structure in real-time. In particular, we propose dynamic change to radii and colors of the nodes to depict neural activity. Changes are typically noticeable when the visualized variable representing the activity is continuous and scaled. In addition, it is beneficial that the visualized variable will have a continuous and interpretable meaning. Notable candidates for such variables are SR calcium activation dynamics or instantaneous firing rates (

To visualize these activity variables we propose to alter the radius and the color of the nodes. When the variable is a signed number (as in SR calcium activation) we use the radius to represent variable's amplitude and assign a color map to represent its sign. When the variable is unsigned, as in the case of PSTH, only one node component (either color or radius) is needed to represent its amplitude, and the other component can be utilized for visualization of additional information such as spike times. For example, when the radius is used to depict the PSTH amplitude, color flickering can be used to display the occurrence of spikes.

For

where _{max} is the maximum radii of the nodes and ρ is the slope factor. The sign of _{i} is determined by the sign of the voltage _{i}. Such scaling of membrane voltages allows discerning active neurons at each given time without having to visualize the raw voltages. While in

Observing the colors and radii scaling over time allows to visually capture the unique patterns of dynamics on a population level, specifically oscillations, sudden bursts, settling down of dynamics. For example, when a population of neurons exhibit oscillations, colors will distinguish representatives of particular groups that are active and dynamically change their tones to display the fluctuation between positive and negative voltages. Indeed, for

We implement the simulation timescale to be typically slower than the actual time in order to: (i) balance computations performed by the backend, and (ii) allow users to capture the details of the dynamics, as visualization in actual timescale tends to happen quickly. We also design the timescales of the stimulations to be dynamic, such that during stimuli transition or neural ablation, running time temporarily slows down to capture the dynamics that occur during the transition.

On the bottom of the interface we locate the time bar, which serves as the interface to interact with the timescales of the visualization (

The

An additional component of the

In addition, features such as “presets” and “save dynamics” are implemented as part of the review system.

Backend neural integration computes neural activity for the whole network for a time interval [

Where ^{c} is the cell membrane conductance, E_{cell} is the leakage potential, and _{i}. The synaptic activity variable is governed by Equation (5), where a_{r} and a_{d} correspond to the synaptic activity rise and decay time, and Φ is the sigmoid function with width β. The equations are based on

While

Where _{d} now including the transmission delay τ_{d} as follows:

Where T_{max} is the maximal concentration of transmitter in the synaptic cleft, V_{j} is the pre-synaptic voltage. Since the computation of network activity is independent from the frontend visualization, the platform allows direct incorporation of such higher order effects.

To support real-time interaction, we implement a synchronization procedure through a communication system between the interface and the backend. Specifically, we use an object ODE integrator which supports event handling and adaptive time-stepping. This functionality allows us to establish a robust protocol between the interface and the backend to support interactive changes to the simulation parameters in real-time between solution points. The protocol monitors the following quantities: t_{computed}: Computed time in the backend neural integration, t_{visualization}: Visualized time in the interactive interface, Δ_{buffer}: Buffer size between t_{computed} and t_{visualization}, τ: Internal refractory period for checking t_{computed} − t_{visualization}.

The system is implemented to keep t_{computed} − t_{visualization} ≅ t_{buffer} at all times such that backend neural integration is always responsive to real-time user interactions, but also accommodates computation of new solutions before the visualization fully catches up with the computation.

Based on these principles the communication protocol is as follows:

(i) The interface sends a command to the backend to compute solutions for the time interval of [t_{computed}, t_{computed} + Δt] given the condition:

(ii) Once the command has been sent, the interface waits for a new block of solution of size Δ

(iii) Once the block is received, the interface resumes to poll whether condition (9) is satisfied. Polling is performed as follows: If the condition is met, the system applies (i). If not, the system goes through a refractory period of τ and then checks again for condition (9).

In _{stimulus}, t_{stimulus} + Δt]. The backend, upon receiving the first command, modifies the input stimuli parameters for stimulation or connectivity matrices for ablation. It then executes the second command by computing the voltage values for all neurons for a given time interval. The computed voltage values are then transmitted to the interface for visualization. This cycle of command and data transmission is repeated indefinitely until the simulation is stopped.

Synchronization between interactive interface and backend neural integration. The backend computes membrane voltage values for future time interval requested by the interface, and transmits them to the graph for visualization. User driven change in the interactive interface, i.e., stimulation or neural ablation, invokes a process that passes the information to the backend where relevant parameters of integration are modified.

In addition to integration of the dynamical equations, the backend ensures that any modification of stimuli amplitude during stimulation is executed in a realistic manner (i.e., no sudden jumps or drops in the stimulus). Ensuring such continuity produces more realistic shift of stimuli from one value to the other. Explicitly, we determine the magnitude of stimulus during the transition through a combination of two hyperbolic tangent functions:

Where _{switch} is the time when the input current was modified, and _{offset} are the constant coefficients that determine the width and initial point of the transition, respectively. Such construction makes sure that every transition takes place in a continuous manner and supports variable transition speeds of

In addition, the backend implements neural ablation by instantaneous modification of connectivity matrices (both gap and synaptic). This step is followed by recalculation of the quantities in the network associated with the modified structure (e.g., the equilibrium states of the network Vth; see Materials and Methods section for more detail). Effectively, when the user ablates a neuron in the interface, an array that keeps track of active neurons (1-present, 0-ablated) is being updated. The modified array is then sent to the backend, where for each ablated neuron, say neuron

Reinsertion of neurons after they were ablated implements the ablation operations in reverse order. Particularly, when the user reinserts the neuron, the interactive interface modifies the active neurons array, such that the corresponding neuron's entry is changed from 0 to 1. The modified array is then transmitted to the backend, where it will restore the corresponding row and column of the connectivity matrices to default values.

We proceed to demonstrate how application of Neural Interactome to

PLM sensory neurons (PLML/PLMR) in

As expected from experimental results and prior work, we observe oscillations in some populations of neurons. We therefore study their periodic cycle. In the top panel of

We identify more detailed properties of the dynamics by inspecting the dynamic graph in review mode (

Most responsive interneurons turn out to be AVB, LUA, DVA, PVR, and PVC (

ALM neurons sense touch to the anterior body region (i.e., frontal body) and induce motor neurons dynamics associated with backward locomotion (Chalfie et al.,

The snapshots of network dynamics while stimulating these neurons are shown in the middle panel of

Zooming into particular populations of motor neurons we observe that individual motor neurons exhibit more complex and irregular patterns than those of the forward stimulation. Unlike the oscillations observed in forward stimulation which are characterized by predominantly smooth sinusoidal form, here motor neurons appear to have oscillatory patterns with various waveforms: some motor neurons repeat steep fluctuations between negative and positive voltage while some exhibit triangular type oscillations above their thresholds.

We also observe more activity within the interneurons. Most prominent ones appear to be AVA, AVDR, AVE, PVR, DVA, ADA, and SABV. Some of these neurons are indeed identified in the literature, AVA, AVD, AVE are characterized to act as modulators for backward motion and DVA is characterized to maintain activity (Chalfie et al.,

It has been recently shown that IL2 neurons regulate the

We present snapshots of network dynamics induced by IL2 (IL2DL/IL2DR, IL2L/IL2R, IL2VL/IL2VR) neurons stimulation in the bottom panel of

In the literature, these motor neurons are known to be involved with control of head muscles. RMG and RMH motor neurons innervate lateral four rows of head muscles while RME neurons innervate all eight rows of head muscles (White et al.,

To validate Neural Interactome's application to investigation of network structural changes, we perform two ablations in conjunction with previously performed scenarios. In particular, we remove AVB and AVA interneurons from the network and repeat the posterior touch response scenario to observe their effects on the dynamics.

According to the literature, the removal of AVB neurons impedes forward locomotion (Chalfie et al.,

Neural dynamics during forward scenario for different structures of the network (non-ablated and ablated neurons).

The visualization does capture weak oscillations within a small group of motor neurons; particularly in Ventricular Dorsal B (VB, DB). Oscillation amplitudes are far less than the healthy dynamics, however, they remain to be relatively in phase and maintain an oscillatory period of ~1.9 s. We are unable to find any oscillatory activity within Ventricular Dorsal type D (VD, DD) neurons, which were out of phase with the activity of B type (VB, DB) neurons in the healthy case. Acknowledging that the two oscillatory phases property is necessary for the worm to perform forward crawling motion (Stephens et al.,

Unlike the removal of AVB interneurons, experiments showed that the removal of AVA interneurons does not impact forward motion (Chalfie et al.,

Taken together our results show that Neural Interactome assists in confirming empirical results reported in the literature, and provides further insights regarding structure and activity associated with examined responses.

In this paper, we present a new visual interactive method, which we call Neural Interactome for studying the dynamics and the structure of a neuronal system (

To elucidate the overall structure and functionalities of the framework, we first define key components: (i) The interactive interface and (ii) the backend neural integration. Next, we apply it to

In addition, we demonstrate the effectiveness and usability of the neural ablation feature in Neural Interactome by ablating hub interneurons (AVA or AVB). AVB ablation leads to network visualization with diminished activity in motor neurons as well as absence of characteristic out of phase oscillatory property required for such motion. The ablation of AVA interneurons, however, shows almost identical set of participating neurons as of the healthy network. We therefore believe that the framework has a potential to reveal other functionalities through multiple ablation scenarios, and provide further insights describing the role of the ablated neurons (Carrillo et al.,

We designed the Neural Interactome to permit updates to both connectivity and dynamic models within the framework as they are further being refined in the future. Connectivity updates will merely require a change in the connectivity matrices. Replacement of a current model with more detailed one or different models (e.g., H-H type model) would merely require the replacement of the model itself, while the synchronization method between the neural neural integration and the interface will ensure that the computed values will be visualized properly. With such flexibility we expect that the framework will be similarly applicable to other neuronal systems: ranging from actual biological networks (such as that of

Beyond the simulation of

Neural Interactome can be either downloaded from Github repository or accessed online via a web interface with following addresses:

In this section, we describe the materials and the methods used for the development of Neural Interactome and its application to

We used two different programming languages for the development of Neural Interactome. We used Python to develop the backend neural integration, and Javascript to develop the frontend interactive interface. For establishing communication protocols between the interface and backend, we used flask-socketIO on Python side and Socket.IO on javascript side. Both flask-socketIO and Socket.IO are libraries that allow real-time bi-directional communication between the client (frontend) and the server (backend) through WebSocket protocols. In the context of Neural Interactome, they were used to establish robust command and data transactions between the interactive interface and backend neural integration.

Several third party libraries were used for each language as well. For Python, NumPy was used for mathematical computations and manipulations of matrices. Several functions from SciPy were used to construct the ordinary differential equation solver and solve the system of linear equations for computation of neural quantities such as V_{threshold} values.

In Javascript, D3.js (Data-driven documents) platform was used to construct force-directed graph representation of neuronal network. For the main webpage development framework, we used AngularJS as it provides optimal functionalities for building dynamic, single page web apps (SPAs).

Threshold potential for each neuron is computed by imposing _{i}. This is equivalent to Solving the following system of linear equations

where the solution x is _{threshold} for the i_{th} neuron.

M_{1} is a matrix of size ^{c} (cell membrane capacitance).

M_{2} is a diagonal matrix where diagonal term in i_{th} row corresponds to _{th} neuron.

M_{3} is a diagonal matrix where its i_{th} diagonal term corresponds to _{eq} is obtained by imposing

_{c} is a 1D vector of size _{c} (leakage potential).

_{j} is a 1D vector of size

I_{ext} is the input stimuli vector where its i_{th} element determines the input current amplitude for the i_{th} neuron.

We used

The following values were used for relative/absolute tolerance and minimum integration step size. Note that the step size is determined adaptively by the solver to guarantee the prescribed tolerances.

Relative tolerance: 10e-9

Absolute tolerance: 10e-10

Minimum step size: 10e-9s (1 ns).

The following values were used for the temporal resolution of simulation and dynamic timescales for visualization. Note that these parameters are for visualization only and are not associated with the integration step in backend integrator.

Temporal resolution: 10 ms

Visualization rate (normal): 100 ms/s

Visualization rate (during transition or ablation): 40 ms/s.

The values of parameters for each connection described in Equation 2–6 are not precisely determined. However, we assume reasonable values reported in the literature (Wicks et al., ^{c} = 10 pS, and membrane capacitance C = 1.5 pF (Varshney et al., _{cell} = −35 mV while reversal potential E_j = 0mV for excitatory synapses and −48 ^{−1} (Wicks et al., ^{*} 2 (for both V and s) and multiply by 10^{−4}. To validate the simulation and the choice of parameters we tested for robustness by perturbing (±20%) individual connection strengths and each neuron's parameters, showing that dynamic functionality persists.

The optimal values for Δ_{buffer}, and internal refractory period τ in Equation 9 depend on computing power of the system. We found the parameters Δt = 50 ms, t_{buffer} = 100 ms and τ = 50 ms (in actual time) to be of reasonable default values which achieve both computational efficiency and synchronization between the interface and backend (_{buffer} are in simulation timescale while τ is measured in computer's internal timer.

Determining the optimal Δt (data stack size) for synchronization and computational efficiency. Two evaluation metrics are collected for different choices of stack size. t_computed − t_vis measures the synchronization between the leading integration time point in backend and leading visualization time point in frontend (lower is better). Stutter counts represents the computational efficiency by counting the number of stutters (i.e., when visualization pauses with t_computed = t_vis; lower is better). Both metrics are measured with identical sessions of 10 s simulation. Final evaluation metric (Lag) is obtained by multiplying these two metrics (lower is better). The results show that Δt = 50

We use _{offset} = 150 _{offset}. Thus, for our choice of parameters for

From Equation 2–4 and physiological parameters specified above, the unit of input current is ^{*}^{−15}^{−13}

ES and JK conceptualized the framework. ES acquired the funding for the study. ES, JK, and WL developed the methodology of the work. JK and WL developed the software. JK and ES validated the results. JK and ES wrote the original draft of manuscript. JK and ES edited and revised the manuscript.

The authors declare that the research was conducted in the absence of any commercial or financial relationships that could be construed as a potential conflict of interest.

We thank Dr. Mark Alkema and Dr. Vivek Venkatachalam for providing valuable feedback, Dr. Gal Haspel for providing updated connectome data, and Dr. Junho Lee for discussions on nictation and providing feedback. We are thankful to the reviewers for their constructive comments. We acknowledge the support of the departments of Applied Mathematics and Electrical & Computer Engineering, the Center of Computational Neuroscience (CNC), and the eScience Center at the University of Washington in conducting this research.

^{1}Web interface available at

^{2}Source code available at