SpineCreator: a Graphical User Interface for the Creation of Layered Neural Models
There is a growing requirement in computational neuroscience for tools that permit collaborative model building, model sharing, combining existing models into a larger system (multi-scale model integration), and are able to simulate models using a variety of simulation engines and hardware platforms. Layered XML model specification formats solve many of these problems, however they are difficult to write and visualise without tools. Here we describe a new graphical software tool, SpineCreator, which facilitates the creation and visualisation of layered models of point spiking neurons or rate coded neurons without requiring the need for programming. We demonstrate the tool through the reproduction and visualisation of published models and show simulation results using code generation interfaced directly into SpineCreator. As a unique application for the graphical creation of neural networks, SpineCreator represents an important step forward for neuronal modelling.
KeywordsModelling tool GUI SpineML Spiking neurons Neuronal networks
With the launch of large multidisciplinary projects, such as the Open Worm and Human Brain Project, neural models are becoming more complex and detailed. Accurate models of regions of the brain involve many types of neuron with complex patterns of synaptic connections, and models can encompass many brain regions. Such models are difficult to understand unless presented using graphical visualisation, especially for collaborators from other fields. In addition, there is a requirement for tools that permit collaborative model building, model sharing, combining existing models into a larger system (multi-scale model integration), and are able to simulate models using a variety of simulation engines and hardware platforms.
XML based model descriptions are recognised as a solution to this latter set of problems (Gleeson et al. 2010; Cannon et al. 2014; Hucka et al. 2003; Richmond et al. 2013). Importantly, they separate the model description from the simulation method, thus freeing the model from dependency on a single simulation platform. They are also declarative and machine readable (allowing efficient code-generation for simulation), portable between different hardware platforms and software, provide strict standards for model description, and allow models to be validated to ensure syntactic accuracy. These features greatly aid collaborative model building, as a set of modeling standards minimise divergence in the way models are specified; subsequently, models can be simulated using the hardware and software tools available to each collaborator. Sharing is facilitated by the interoperability of models described in a strict validatable format, as the common description format guarantees that models developed by different groups can be integrated to form larger systems. By utilising a layered approach (Raikov and De Schutter 2012), XML formats can separate semantic layers: for example, the equations used to simulate the neurons are separated from the network structure of the model, and the model separated from the experimental paradigm. This approach enables efficient reuse of computational elements in different models.
Despite these advantages, XML based models are difficult and time consuming to create by hand, and it is difficult even for a user familiar with XML to read and visualise a model directly from an XML file. This limitation is especially important in multidisciplinary projects, where it is vital that modellers can easily and clearly share ideas with collaborators from other fields. For these reasons XML formats benefit greatly from associated creation tools, which can either allow an efficient condensed specification of the model (i.e. programming language interfaces) or advanced visual manipulation of the model structure (i.e. graphical interfaces). The impact of content-authoring tools can be seen from the extensive toolsets that surround the most successful XML formats (Gleeson et al. 2010; Cannon et al. 2014; Hucka et al. 2003). Visualisation tools can take one of two forms. The first is as an extension to a model creation toolchain - once a model is described it can then be visualised as read-only. The second is a graphical creation tool, where the visualisation is used to build and interact with the model. The advantage of the second form is that it also improves the accessibility of modelling, which is often predicated upon experience in computer programming, thus allowing students and researchers with non-computational backgrounds (e.g. Psychology and Biology) to contribute to modelling. For this reason we focus on the second form of visualisation tool.
We have named our tool SpineCreator, as the XML format behind our tool is SpineML (Richmond et al. 2013), an XML format for the description of neural models. This format permits modelling at the level of networks of spiking point neurons (SNN) or rate-coded neural units (RCN). Our tool provides an easily accessible yet powerful graphical interface for model creation, and additional functionality to extend the capabilities of the toolchain (e.g. by enabling the use of neuron locations in specifying neural connectivity).
Several existing model creation tools utilise programming languages to specify models (specifically Python which uses scripts (small non-compiled programs)) including PyNN (Davison et al. 2008), Brian (Goodman and Brette 2008), and pyNEST (Eppler et al. 2008)). These tools allow the efficient description of models using programming structures (e.g. for-loops), however they necessarily require familiarity with computer programming, which reduces the accessibility of both the models and the modelling approach to experimentalists, theoreticians, and students lacking experience in programming. We here advocate an approach where users enter as much information as possible in a conceptual form using graphical representations of the model, including the entry of differential equations rather than their iterative solutions, in order to promote accessibility.
Informative Model Presentation
Except for extremely simple models, in most current tools used for model creation the user must extract information from the model description to generate a separate diagram in order to present the model; diagrams are often used in publications rather than lists of equations to describe model architectures (Nordlie et al. 2009). The tool presented here uses the visual representation of the model in 2D and 3D as the means of building and interacting with the model, rather than considering it a post-hoc product of a formal description. This tight integration of model construction and visualisation greatly facilitates the design process and identification of errors in the model, for example by highlighting the afferent connections of a single neuron to check for correctly generated connectivity.
Facilitation of Model Creation
To simplify code generation it is sometimes helpful to limit the high level descriptive features of an XML language. One example in SpineML is the specification of connectivity between neural populations. All types of connection scheme are supported as connectivity can be described by source neuron and destination neuron connection pairs, however it may be convenient to the user to describe the connectivity in other ways. For example, the connectivity between two neural populations may be described as a function of the distance between each pair of neurons; this is not supported in SpineML, however a creation tool can remove these limitations by adding functionality to describe distance based connectivity. Models can then be output as pure declarative SpineML for simulation or sharing, with a procedural method of generating the connectivity specified in a separate file specific to the creation tool (or annotations within the XML).
Access to Simulators and Simulation Results
Many procedural, programming language based, modelling tools allow both support for simulating models in external simulators and the collection of data from simulations into memory. The data from the simulation can then be analysed and visualised using the tools available to the programming language, which in the case of Python are extensive. It is not possible (but also not necessary) for a graphical interface to match the level of flexibility found in programming languages, however it is necessary for the interface to provide access to simulation tools and the retrieval of data for graphical evaluation.
We now describe briefly three neural models at differing levels of detail, from a rate-coded network to a biophysically derived microcircuit model. These models have been created using our graphical tool and are used in the following section to illustrate the capabilities and flexibility of our software. Full details of all the models can be found by downloading them from the SpineML website (http://spineml.github.io/models/) and opening them in SpineCreator.
Basal Ganglia RCN
Basal Ganglia SNN
This model is a new model based upon the GPR Basal Ganglia model described above. The GPR rate-coded model is translated into a spiking neuron model using leaky integrate and fire (LIF) models of neural dynamics. Since each LIN represents a group of spiking neurons, each is replaced by several LIF neuron models. A study of population behaviour of neurons in the Frontal Eye Fields of macaque monkeys found that robust neural responses could be obtained with seven neurons or seven repeated trials (Bichot et al. 2001), so we replace each LIN with seven LIF neuron models on the understanding that this represents a lower bound on the number of neurons that can provide a robust group response. Each channel through the BG is therefore expanded to seven LIF neurons wide. We replace the one-to-one connections between LIN units with all-to-all connections between the seven neurons in a channel and reduce all the weights in the model sevenfold as there are seven times more inputs to each LIF neuron than to each LIN unit. Next, to convert between the LIN input values and offsets and the input and intrinsic currents to the LIF neuron, all current values in the LIF model (excepting the intrinsic current in the STN) are multiplied tenfold (this value is chosen by hand to allow transmission of information between the layers). The remaining changes for the conversion consist of replacing the analog cortical input to the model with a regular spiking input, adding variation to the membrane time constants (originally all 25 ms) so that all LIN neurons do not spike simultaneously (for this the time constants were obtained from a uniform distribution with a minimum value of 20 ms and a maximum value of 30 ms), and adding exponentially decaying current based synapses with a time constant of 4 ms. In addition the model provides a better qualitative match to the results of the RCN version if the influence of dopamine on the D2 receptors is slightly reduced.
This model is an anatomically accurate model of the striatum - the main input nucleus to the Basal Ganglia. The model comprises a biophysically based description of a 300 μm cube of the Striatum, with numbers of each neuron types and connectivity commensurate with that volume. The original model was written as a combination of a C numerical simulation and a set of Matlab scripts for generating parameters, a form not amenable to further development or sharing as the model details are obscured by the syntax. The model uses 2-variable point neurons with physiologically realistic attributes such a dopaminergic modulation (Humphries et al. 2009a) and gap junctions (Humphries et al. 2009b), based on the Izhikevich neuron model. This model will hereafter be referred to as the Striatum Model. Translating this model into SpineML facilitates sharing, portability, collaboration and accessibility, which are impractical in the model’s currently implemented form of Matlab and C.
The full description of this model in SpineML is difficult if written using a text editor, as the model uses a distance based connectivity scheme which must be described as a list of explicit source, destination and delay triplets (Humphries et al. 2010). We will show how SpineCreator’s extended connectivity types allow for the automated generation of this connectivity, and how SpineCreator facilitates the compact description of this complex model in SpineML.
Outline of the SpineCreator Interface
The SpineCreator GUI provides an interface with a one-to-one mapping between XML tags and the GUI interface elements. The stages of the modelling process are also analogous to the levels of description used to investigate architectures in the brain, from individual neurons to complete sensori-motor systems, followed by an external experimental paradigm. The GUI elements are implemented to allow a user to apply their existing knowledge of software UI design features such as undo/redo, recently opened file lists, drag and drop and property editing.
Component Creation. SpineML Components representing neuron body dynamics, weight update rules, synaptic dynamics, or general dynamical processes, which can be created or imported, and modified using a graphical interface.
Network Creation. SpineML Network files can be imported and combined, or created. SpineML Components in the same project can be used in the network.
Experiment Creation. SpineML Experiments for each project can be created and modified.
Graphing. Plots Analog or Event data logged from experiment runs. The plots update automatically when new experiments are run. Line and raster plots of logged data can be visualised and saved as Portable Document Format (.pdf) or Portable Network Graphics (.png) files.
3D visualisation. The 3D layout of the network can be constructed and visualised. The neurons in Populations can be assigned locations in 3D space using procedural layout descriptions which can be created in SpineCreator. Connectivity patterns can be visualised, and the extended connection types that SpineCreator supports can be configured (see “Extended connectivity types↓” section). This visualisation can be output as a Portable Networks Graphic (png) or Scalable Vector Graphics (svg) image file.
We shall now demonstrate the workflow of SpineCreator for creating an SNN model using an example.
The Component list provides an overview of the Components in the current Project, and is colour coded to provide immediate visual feedback to show which Components are valid (i.e. have complete definitions), invalid, and are in use in the Network, allowing the user to quickly detect errors in Components. Component dynamics are displayed graphically, as shown in Fig. 4↓, where they describe the Striatum model’s FSI neuron behaviour (replicated from Humphries et al. (2009b)). Importantly, Components can be modified, renamed and duplicated here even if they are in use. In the Striatum Model, all neuron types are extended versions of a form of the Izhikevich neuron model (Izhikevich 2007). This means that the process of creating the individual neuron types can be simplified by first creating or importing a SpineML Component for this neuron type, and then duplicating and modifying this component to form the three neuron types in the Striatal Model. By reusing an existing Izhikevich Component, the time taken to create the Components is significantly reduced, as is the likelihood of errors. Finished Components can be exported as separate SpineML files, for use in other Networks and Projects. To prevent mistakes such as deleting an element of a Component being costly in terms of development time there are separate undo stacks provided for each Component.
It should be noted that dimensionality units can be added to Parameters, State Variables and ports, and is used in the Network Creation section of the software to reduce errors by only allowing ports with matching types (event/analog/impulse) and dimensions (mV/pA etc…) to be connected.
After creation, the Components can be used to build networks in the Network Creation section of SpineCreator to build the model.
Components created in the Component Creation section of SpineCreator, or imported from the file menu, are added to the Components available within the Project. These components can then be used in the Network Creation section of SpineCreator to construct SNN models.
Figure 2↑ (C) shows the Network Creation section of SpineCreator with the Striatal model. The left hand section of the interface shows a large 2D view of the model, topped by a toolbar allowing the addition of new objects to the network or the removal of existing objects. The right hand section of the interface shows a context sensitive panel for detailed configuration of the Network. An undo stack is also provided for the Network, allowing mistakes such as unintentional deleting of objects to be rectified easily.
Not all information about the model is presented to the user at the same time, in order to provide an uncluttered interface where useful information is not obscured by irrelevant information. The organisation of the information presented is as follows.
This high level structural overview of the model is always present, which includes the Populations comprising the model, the Projections between them, and the Generic Inputs connecting components. These are presented in a 2D graphic which the user can arrange to form a flow diagram, as shown in Fig. 2↑. The user can therefore arrange the 2D layout using drag and drop to match the conceptual diagrams of the model; in Fig. 1↑ the correspondence between the conceptual diagram for the GPR model and the 2D Network Creation visualisation of the model can be seen. By presenting the model structure in 2D, the objects that make up the model can be arranged to clearly show their relationships to other objects, avoiding the possibility of objects obscuring each other as can occur in a 3D projected view. In addition the Populations have further information presented in this view: the Population name, the number of neurons in the Population, and the component type used by the Population. Populations can be assigned a display colour to facilitate visual identification and grouping. Projections also display extra information: thicker lines and a set of dots at the start of the projection indicate the number of Synapses in a Projection with more than one Synapse, and line colour is used to indicate the connection type used for Projections. Displaying this information ensures that the user always has an overview of the structure of the model, which can then be actively interrogated to retrieve or alter detailed information on single objects through the second level - selection.
Objects in the 2D graphic can be selected individually, or as a group (using the shift key to add to the selection, or the right mouse button to select objects inside a dragged box). Selecting a group of objects allows these objects to be moved together in the 2D graphic. Individual selection displays an interface with information about the selected object in the panel to the right of the 2D view. These diagrams can be exported for inclusion in manuscripts as either Portable Networks Graphic (png) or Scalable Vector Graphics (svg) image files.
Context Sensitive Properties Panel
The interface presented in this panel is different depending on the class of object selected, and allows the object to be configured. For example, selecting a Population object presents an interface where the name, size, colour and Component of the Population can be set. Once a Component is assigned for the Population, the input interface changes to present an interface for configuring the available Properties (StateVariables and Parameters) of the assigned Component (see Fig. 2↑). If several Populations need to share the same Properties (even if the Components differ) the copy and paste buttons can be used to copy and paste the Property configuration from one Population to another.
The 2D Network Creation interface provides an efficient and clear method of creating a model. However for some models, such as the Striatal Model described here, 3D information about neuron locations within a Population or connectivity between Populations is structurally important, and the 3D interface provides a more natural way to configure and observe connectivity.
3D Model Visualisation Interface
3D visualisation is provided in the Visualisation pane of SpineCreator. The interface consists of a 3D viewport to the left of the interface, topped by a toolbar with options to toggle the display of neuron indices and to toggle isometric projection of the model. To the right is a panel with a tree diagram of the network for selecting objects to configure and toggling which objects are visible. Below the tree diagram is a section with a configuration interface for the currently selected object. Figure 2↑ (B) shows the Visualisation interface.
3D Location Generation
To describe the 3D layout of neurons within a Population, SpineCreator provides a procedural method, which iterates through each neuron in turn and calculates the x, y and z co-ordinates using a set of user specified equations to advance values from their previous states. The process can be considered as an animation, with each subsequent frame representing the location of the subsequent indexed neuron in the population. In addition to x, y and z extra state variables can be added and updated each iteration. If a variable is used in an equation then the value from the previous iteration will be inserted (or zero for the first iteration), unless the value has been updated in the current iteration. Figure 6↓ shows a diagram of the procedural method for a grid with a row length of 3 μm. This layout was used in the BG SNN model to create six channels consisting of seven neurons each. New types of layout generation are specified using a graphical interface.
The equations used in a layout can also include uniform random numbers by using the rand() term. A seed can be specified in order to generate consistent random layouts, and a minimum distance can be specified to prevent neuron co-ordinates from being closer than is biologically realistic. A 3D layout, using random numbers to specify the x, y and z co-ordinates of each neuron, was used to generate the co-ordinates of the neurons in the Striatal Model. Using procedural layouts increases the speed of specifying co-ordinates in comparison with entering explicit co-ordinate lists, and the neuron co-ordinates can then be used with SpineCreator’s extended connectivity types, which will now be described.
Extended Connectivity Types
Adding parameters to the SpineCreator GUI is performed using the #PARNAME comment, which gives a name used as a label for the parameter, and a #LOC which describes the row and column where the parameter should be added in a grid for laying out the parameters. The order of the parameters in the code denotes the order they have in the corresponding Python function call, and allows the label to have a more descriptive name than the variable used in the function. In addition there are two more comments that are parsed; #HASWEIGHT and #HASDELAY, which inform SpineCreator if the script needs to generate a weight and/or a delay. If a weight is generated SpineCreator will provide a drop-down list of the corresponding Properties in the WeightUpdate Component, and the selected Property will have the weight values inserted when the connectivity is generated.
The function itself has arguments srclocs and dstlocs, which are Lists of Tuples, each Tuple containing the x, y, and z co-ordinates of the neuron at that index in the List.
Generating the explicit list of connections for larger Populations is slow, requiring a lot of computation to be performed, and therefore we minimise the amount of generation using the following strategies. Within SpineCreator the connectivity lists are not regenerated unless the script text, script parameters, or the source or destination sizes change. When writing the model out for simulation or storage, it is important that SpineCreator stores both the means of generating these extended connectivities, as well as the full ConnectionList in order that the XML version of the model is always a valid and accurate SpineML model. To achieve this, only if the connectivity has not already been generated by SpineCreator is it generated, and the full connectivity is saved in the SpineML model as a ConnectionList, and the Python script and parameter values are saved separately in the ConnectionList Annotations tag. This method has two main advantages. Firstly it guarantees an accurate SpineML model is always saved, and can therefore be loaded into other creation tools. Secondly, it speeds the process of loading a model into SpineCreator, as the connectivity does not need to be generated each time.
It should additionally be noted that Python scripting is defined in SpineCreator’s codebase as a ‘generator’ class, which acts via a ConnectionList class. This method of constructing the codebase allows that future standardised connectivity description formats can be added with minimal effort to the developers. Pragmatically, however, any future additional specification methods should still store the connectivity as a ConnectionList in the XML to maximise simulator support. Standardisation of certain Annotations within the ConnectionList tag could then provide a means of sharing the generation method between tools.
Experiment Creation, Simulation and Simulation Data Visualisation
The interface is based on the interface metaphor of a workbook, with the panel to the left of the interface listing the Experiment entries. When these are selected the columns to the right fill with text descriptions of the manipulations for the Experiment. By using sentences with bold fonts to emphasise key data, information about the Experiment can be found at a glance.
As SpineML is a simulator independent model storage format it aims to support a wide range of simulators. As support for simulators increases it is important that SpineCreator allows easy addition of simulators by the user. Access to simulators from the graphical interface is not essential, but is required to meet SpineCreator’s of making modelling more accessible. To this end simulators are supported through scripts (for example, BASH on UNIX and Batch file on Windows) that operate on a model stored in SpineML. These scripts can be configured using an extensible list of system environment variables. Thus the user can be given a simple set of instructions by a simulator author that allows them to add support for that simulator to SpineCreator. This script based system also allows the same scripts to be used by other SpineML model creation tools or from the command line with a hand written SpineML model.
Other simulators are supported as described in the original SpineML paper (Richmond et al 2013), and ongoing development and support of simulator targets for SpineML is kept up to date on the SpineML website at http://spineml.github.io/simulators/, where installation instructions for the SpineML BRAHMS code generation target can be found.
Logging and Graphing
Features to Facilitate Collaboration and Dissemination
In any collaborative or shared model creation software, versioning is important. We therefore have integrated the Mercurial version control system (VCS) ( http://mercurial.selenic.com/) into SpineCreator using a unified versioning structure that will support additional VCS in the future. The VCS is automatically detected on the user’s computer and these options for version control are only presented if Mercurial is present. Currently repositories for SpineCreator Projects must be created outside of SpineCreator, but subsequently the repository can be managed and queried from within the tool.
Publication Quality Diagram Output
In this paper we have presented SpineCreator, a GUI for the creation of neural models using the declarative XML format, SpineML. Creation tools are essential for the uptake and usability of any XML based neural model specification format, as the effort of writing models by hand in such formats is a major drawback for all but the simplest models. This interface facilitates the creation of SpineML models, and increases the accessibility of the SpineML modelling toolchain to those without a background in computer programming. The extended connectivity types allow the creation of complex rule based connection schemes, thereby extending the functionality of the SpineML format. The visualisation features of the interface allow the structure of the model to be easily presented and understood. SpineCreator imposes no limits on the size of models, barring the availability of memory on the host machine.
Facilitating the Creation of Models
Primarily, SpineCreator is designed to facilitate the creation of neural models. This can be undertaken using SpineCreator as the sole model creation tool, however since SpineCreator saves the model in the SpineML XML exchange format models can be easily authored using several tools. For example, it may be beneficial to create repetitive structures in a programming language, where a for-loop can be used to iterate over each element. The resulting model can then be imported into SpineCreator and details can be added once the model is organised in a 2D flow-diagram form where it is easier to see the relationships between the elements. To benefit such collaboration between creation tools we provide an online resource describing the structure of the SpineCreator Project file as well as the Annotations that SpineCreator adds to the SpineML Network file. This can be found at http://spineml.github.io/spinecreator/.
Model creation is also facilitated through some of the features provided by the SpineML format structure, as using a layered approach to describe models (Raikov and De Schutter 2012) facilitates reuse. Components can be reused within the same model, and this is an approach adopted in many simulator independent and simulator dependent tools (e.g. PyNN). Networks can also be reused by their inclusion in new Projects, thus a Systems Integration approach, where existing models of different parts of brain function can be combined into a model of a larger part of the brain, is supported by SpineCreator.
Several further features of SpineCreator also play a role in facilitating model creation:
By only presenting information when an object is selected, and providing a clear visual indication of the selected object, SpineCreator minimises the amount of detailed information presented to the user and facilitates the identification of the information the user is seeking. This interrogative approach to finding information is used in SpineCreator as an alternative to presenting all information at the same time or in a specific order as in a script. This approach increases the speed with which information can be located and changed by minimising the number of options presented to the user at each stage - increasing the ease with which a model can be created and preventing overwhelming inexperienced users with a cluttered interface.
Version control is essential to any large, collaborative project. While version control is possible with any tool, as VCSs are capable of versioning even binary files, the advantage of SpineCreator is that the version control is integrated into the graphical interface. This methodology ensures that the functionality is accessible without requiring knowledge of specific command line tools. Using version control reduces the chance of model divergence, and allows verification that the right version of the model is being used to reproduce results.
The integration of standardised diagram output in SpineCreator helps model authors by reducing the time spent creating diagrams of models, and removes the possibility of inaccurate diagrams by creating the diagrams directly from the model itself. Most importantly, providing diagram output in a standard form ensures that diagrams are clear and understandable.
The extended connection types added to SpineML by SpineCreator allow complex connectivity patterns to be described simply using the graphical interface and visualised in 3D. This extension removes the requirement to use additional software or programming to create such connectivity and thus makes the SpineML toolchain more accessible to non-programmers. Likewise, the built in graphing allows simple raster and line plots of simulation outputs to be created without the use of external tools, providing immediate feedback on the results of a simulation, without having to use external graphing programs.
Improving Accessibility Through a Clear Interface to the Model
Collaborative modelling and sharing models to promote reuse is becoming increasingly important as our understanding of neural systems increases, and models grow in scale and complexity. Large projects involving multiple disciplines, including experimentalists and theoreticians, are widespread. In such projects it is important that collaborators without a programming background can understand and contribute to computational modelling. Collaboration and sharing also increases the number of checks the model undergoes (decreasing the possibility of errors). It is also important that the end products of these projects are proliferated into the wider scientific community in a form that is both accessible and understandable. The graphical representations of models that SpineCreator provides can help with these goals.
When sharing and exchanging models it is important that the model recipient is able to understand the model rapidly. Graphical representations provide a conceptual overview of the structure of the model, and can reference the flow of the model through flow-chart style diagrams of Populations and Projections, or reference the anatomical basis of the model using three dimensional representations. Through these references the recipient of the model can more easily understand the model. This graphical representation allows SpineCreator to fit into the workflow of a large project by providing an entry point into understanding a complex model, both for modellers looking to extend or modify the model, or for experimenters looking to understand the modelling work and use it to guide further experiments. Thus, collaboration between experimentalists, theoreticians and modellers is facilitated by making the model accessible and understandable to those without a background in computer programming.
The accessibility provided by a graphical representation also enables SpineCreator to be used as an educational tool for the teaching of neuron dynamics in disciplines where computer programming skills are not taught. Currently in other common model description formats (Davison et al. 2008; Eppler et al. 2008) programming is a requirement for creating neuron dynamics whereas SpineCreator removes this requirement, making the field more accessible.
Levels of Use
While SpineCreator can provide a clear interface for non-programmers, it also supports different levels of use depending on the user’s level of understanding. At the simplest level users can build either individual neurons as components to integrate into an existing network, or build networks out of existing components, or modify the parameters of an existing model and through experimentation discover how this affects the model’s behaviour. This process requires no programming knowledge.
Users who are unfamiliar with computer programming can use SpineCreator to build components and networks using extended Python connectivity provided for them, also without requiring any programming knowledge.
Finally, advanced users who have programming experience can create extended Python connectivities using all the features of SpineCreator.
By facilitating exporting publication quality diagrams SpineCreator can also help the dissemination of finished models for users in the research community, and can facilitate collaborative work using the version control interface built into SpineCreator.
By including this tiered approach users can utilise SpineCreator at all levels from student through to researchers, without needing to appreciate the more advanced features SpineCreator offers more experienced users.
Comparison with Existing Tools
There is no direct comparison for SpineCreator amongst the existing model creation tools. NeuroConstruct (Gleeson et al. 2007) is a simulator independent model creation GUI utilising an XML description format for storage, however it is focused on the creation of detailed compartmental neural models and networks in the NeuroML language - for creating SNN models it has a high learning curve and unintuitive interface, and it cannot be used to construct RCN models. Aside from SpineCreator, there is no equivalent of NeuroConstruct for SNN and RCN creation.
SpikeNET (Delorme et al. 1999; Delorme and Thorpe 2003), XNBC (Vibert et al. 1997, 2003), and SNNAP (Ziv et al. 1994) are software packages that consist of an integrated creation tool and simulator. These tools focus on providing a set of standard neuron models, such as the LIF and Izhikevich models, and do not permit the user to modify the dynamical equations of one of these types, or add a new type. One requirement of the SpineML toolchain is that it can be used to create models that currently can only be created in C and Matlab, and thus these tools do not fulfill that requirement.
NeuralSyns (Sousa and Aguiar 2014) is a set of graphical tools for creating and simulating neural networks of spiking neurons. The tools focus on removing the requirement for programming, and providing 3D visualisations of neurons and simulation activity, however programming is required to add neuron model types. These requirements highlight two main differences in philosophy from SpineCreator, as NeuralSyns uses an internal format for storing models, which is not designed to work as part of a wider toolchain. This format relies on the use of a single simulator, while the SpineML format used by SpineCreator provides a full specification of the model, which allows any user to translate the XML description into standardised running code. NeuralSyns also provides graphical visualisation as a simulator feature, rather than as a part of the modelling process, instead using a graphical interface of buttons and menus. Therefore while there is some overlap between the tools there is also a clear distinction.
Several tools use the high level Python programming language for model creation (PyNN (Davison et al. 2008), Brian (Goodman and Brette 2008), pyNEST (Eppler et al. 2008)). These tools use a scripting approach where a set of functions are used to build the model. The scripting approach allows for extremely compact descriptions of models, but trades off model comprehensibility, as scripted models can be extremely difficult to read and understand. On the other hand, declarative formats are inflexible, and can require considerable duplicated content. SpineCreator tries to combine these two approaches, providing structure and constraint by using a declarative XML format to save models, but also providing tools such as copy/paste, one click duplication of Components, and extended connectivity types to facilitate the creation of these declarative models. Always, the declarative output of the procedural syntax can be visualised to confirm that the declarative model output is as expected.
Limitations and Future Development
SpineCreator is intended as a first creation tool for the SpineML toolchain, and it is expected that it will sit alongside other creation tools, all exporting models to a shared XML format. In addition, SpineML is a proposal for the completion of the NineML specification, and as such it is the intention to integrate SpineML with NineML and NeuroML 2.0’s LEMS format.
Information Sharing Statement
The example models presented within this paper (namely the GPR Basal Ganglia models and Striatal model) are available in complete form from the SpineML website (http://spineml.github.io). Additional documentation is also available to aid users in reproducing the experiments and results presented.
SpineCreator is available to download from the SpineML website at http://spineml.github.io/spinecreator/, where extensive instructions are provided on installation under Macintosh OSX and Linux. There is additionally a list of supported backend simulators on the SpineML website at http://spineml.github.io/simulators/.
This work was supported by ESPRC via the Biologically-Inspire Massively Parallel Architectures (BIMPA) grant (EP/G015627/1), the Green Brain: Computational Modelling of the Honeybee Brain grant (EP/J019690/1), and via EPSRC Delivery Plan ‘Kickstart’ funding.
Open Access This article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.