sango 1.0.0__py3-none-any.whl

sango/__init__.py

@@ -0,0 +1,4 @@
+from .core import NodeGroup, EdgeGroup, NodePort, NodeList
+from .network import Network
+
+__version__ = "1.0.0"

sango/backend/__init__.py

@@ -0,0 +1,3 @@
+from .stacs.stacs import SimSTACS
+from .brian.brian import SimBrian
+from .fugu.fugu import SimFugu

sango/backend/brian/brian.py

@@ -0,0 +1,292 @@
+import os
+import sys
+from pathlib import Path
+import importlib.util
+
+try:
+	import brian2
+except ImportError:
+	brian2 = None
+if brian2 is not None:
+    from brian2 import NeuronGroup, Synapses, SpikeGeneratorGroup, SpikeMonitor
+    from brian2 import ms, defaultclock
+
+import time
+from collections import Counter
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Brian Simulation Backend
+class SimBrian:
+    def __init__(self, dsl_net):
+        if brian2 is None:
+            raise ImportError("brian2 package is required for SimBrian")
+        
+        self.dsl_net = dsl_net
+        self.tstep = 1.0*ms
+        self.timesteps = None
+
+        self.node_map = None
+        self.spike_list = None
+    
+        self.model_registry = self.import_registry()
+
+    # Dynamically import the model registry files
+    def import_registry(self):
+        registry = dict()
+        registry_dir = Path(__file__).resolve().parent / 'registry'
+        sys.path.insert(0, str(registry_dir.parent))
+        for file_path in registry_dir.glob("*.py"):
+            module_name = f"registry.{file_path.stem}"
+            spec = importlib.util.spec_from_file_location(module_name, file_path)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            registry.update(module.model_registry)
+        sys.path.pop(0)
+        return registry
+        
+    # Convert between dsl model to brian2 model
+    def rekey_model(self, data):
+        for key, value in self.model_registry[data['model']]['state'].items():
+            if value['dsl'] is not None:
+                data[key] = data.pop(value['dsl'])
+            else:
+                data[key] = value['default']
+        return data
+
+    def compile(self, debug=False):
+        self.debug = debug
+        
+        # Convert network to brian
+        start_time = time.perf_counter()
+        self.to_brian()
+        end_time = time.perf_counter()
+        self.compile_time = end_time - start_time
+        if self.debug:
+            print(f"Compile time: {self.compile_time}")
+        
+    def run(self, timesteps=10.0, verbose=False):
+        self.timesteps = timesteps*self.tstep
+        self.verbose = verbose
+
+        # Run network
+        start_time = time.perf_counter()
+        self.brian_net.run(self.timesteps)
+        end_time = time.perf_counter()
+        self.run_time = end_time - start_time
+        if self.verbose:
+            print(f"Run time: {self.run_time}")
+
+    def to_brian(self):
+        # Get a flattened graph object
+        self.dsl_graph = self.dsl_net._topology.to_nx()
+        defaultclock.dt = 1.0*ms
+
+        # Convert to Brian2 network objects
+        self.num_nodes = self.dsl_graph.number_of_nodes()
+        self.node_index = dict()
+        self.node_data = [dict() for _ in range(self.num_nodes)]
+        self.edge_data = [dict() for _ in range(self.num_nodes)]
+        self.group_count = Counter()
+        self.local_index = [0 for _ in range(self.num_nodes)]
+        self.edge_set = set()
+        self.spike_input = []
+        
+        # Add input model (IN) to the beginning of the group
+        self.group_count['IN'] = 0
+
+        # Global node data
+        for n, (node, data) in enumerate(self.dsl_graph.nodes(data=True)):
+            self.node_index[node] = n
+            self.node_data[n] = self.rekey_model(data)
+            self.group_count.update([self.node_data[n]['model']])
+            self.local_index[n] = self.group_count[self.node_data[n]['model']] - 1
+            if self.model_registry[self.node_data[n]['model']]['graph_type'] == 'input':
+                self.spike_input.append(data['times'])
+
+        # Remove the input model (IN) if counts are zero
+        if self.group_count['IN'] == 0:
+            del self.group_count['IN']
+
+        # Get the model insertion order of our counter, and organize node map by group
+        self.group_index = {key: index for index, key in enumerate(self.group_count.keys())}
+        self.group_sorted_count = [self.group_count[group] for group in self.group_index]
+        self.group_offset = [0] + [sum(self.group_sorted_count[:i+1]) for i in range(len(self.group_sorted_count))]
+        self.node_map = {key: self.group_offset[self.group_index[self.node_data[n]['model']]] + self.local_index[n]
+                         for key, n in self.node_index.items()}
+        
+        # Global edge data
+        for source, target, data in self.dsl_graph.edges(data=True):
+            s = self.node_index[source]
+            t = self.node_index[target]
+            self.edge_data[s][t] = self.rekey_model(data)
+            self.edge_set.add((self.edge_data[s][t]['model'], self.node_data[s]['model'], self.node_data[t]['model']))
+            
+        # Spike generator inputs (sorted)
+        if not self.spike_input:
+            pass
+        else:
+            spike_index = []
+            spike_times = []
+            for i, times in enumerate(self.spike_input):
+                for t in times:
+                    spike_index.append(i)
+                    spike_times.append(t*ms)
+            self.spikegen_times, self.spikegen_index = [list(t) for t in zip(*sorted(zip(spike_times, spike_index)))]
+        
+        # Container for local neuron states (by group)
+        self.neuron_states = dict()
+        for name in self.group_count.keys():
+            self.neuron_states[name] = dict()
+            for state in self.model_registry[name]['state']:
+                self.neuron_states[name][state] = []
+
+        # Container for local synapse states (by connection)
+        self.synapse_connections = {f"{n}_{s}_{t}": {'i': [], 'j': []} for (n,s,t) in self.edge_set}
+        self.synapse_states = dict()
+        for name, source, target in self.edge_set:
+            full_name = f"{name}_{source}_{target}"
+            self.synapse_states[full_name] = dict()
+            for state in self.model_registry[name]['state']:
+                self.synapse_states[full_name][state] = []
+        
+        # Neurons
+        for n, data in enumerate(self.node_data):
+            name = data['model']
+            for state in self.model_registry[name]['state']:
+                self.neuron_states[name][state].append(data[state])
+        
+        # Synapses
+        for s in range(self.num_nodes):
+            for t, data in self.edge_data[s].items():
+                full_name = f"{data['model']}_{self.node_data[s]['model']}_{self.node_data[t]['model']}"
+                self.synapse_connections[full_name]['i'].append(self.local_index[s])
+                self.synapse_connections[full_name]['j'].append(self.local_index[t])
+                for state in self.model_registry[data['model']]['state']:
+                    if state == 'delay':
+                        # Brian has a default delay of 0ms (to get to the next timestep)
+                        self.synapse_states[full_name]['delay'].append((data['delay']-1.0)*ms)
+                    else:
+                        self.synapse_states[full_name][state].append(data[state])
+
+        # Brian Network
+        self.brian_net = brian2.Network()
+        self.input_groups = dict()
+        self.neuron_groups = dict()
+        self.synapse_groups = dict()
+        self.spike_monitors = dict()
+
+        # Create input and neuron groups (and their spike monitors)
+        for name, count in self.group_count.items():
+            # Spike generator group
+            if self.model_registry[name]['graph_type'] == 'input':
+                self.input_groups[name] = SpikeGeneratorGroup(count, self.spikegen_index,
+                                                              self.spikegen_times, sorted=True)
+                self.spike_monitors[name] = SpikeMonitor(self.input_groups[name])
+            # Regular neuron model group
+            elif self.model_registry[name]['graph_type'] == 'neuron':
+                self.neuron_groups[name] = NeuronGroup(count, model=self.model_registry[name]['model_eqs'],
+                                                       threshold=self.model_registry[name]['threshold'],
+                                                       reset=self.model_registry[name]['reset'],
+                                                       method=self.model_registry[name]['method'],
+                                                       events=dict(self.model_registry[name]['events']))
+                # These "run regularly" methods bypass the standard Brian integration step
+                if 'run_regularly' in self.model_registry[name]:
+                    for program in self.model_registry[name]['run_regularly']:
+                        self.neuron_groups[name].run_regularly(program['eqs'], when=program['when'])
+                # These "run on event" methods trigger when a custom event happens
+                if 'run_on_event' in self.model_registry[name]:
+                    for program in self.model_registry[name]['run_on_event']:
+                        self.neuron_groups[name].run_on_event(program['event'], program['eqs'])
+                # Copy over states
+                for state in self.model_registry[name]['state']:
+                    getattr(self.neuron_groups[name], f"{state}")[:] = self.neuron_states[name][state]
+                self.spike_monitors[name] = SpikeMonitor(self.neuron_groups[name])
+        
+        # Create synapse groups
+        for (name, source, target) in self.edge_set:
+            full_name = f"{name}_{source}_{target}"
+            if self.model_registry[source]['graph_type'] == 'input':
+                self.synapse_groups[full_name] = Synapses(self.input_groups[source],
+                                                          self.neuron_groups[target],
+                                                          model=self.model_registry[name]['model_eqs'],
+                                                          on_pre=self.model_registry[name]['on_pre'])
+            else:
+                self.synapse_groups[full_name] = Synapses(self.neuron_groups[source],
+                                                          self.neuron_groups[target],
+                                                          model=self.model_registry[name]['model_eqs'],
+                                                          on_pre=self.model_registry[name]['on_pre'])
+            # Copy over connections
+            self.synapse_groups[full_name].connect(i=self.synapse_connections[full_name]['i'],
+                                                   j=self.synapse_connections[full_name]['j'])
+            # Copy over states
+            for state in self.model_registry[name]['state']:
+                getattr(self.synapse_groups[full_name], f"{state}")[:,:] = self.synapse_states[full_name][state]
+        
+        # Add all the objects to the network
+        for value in self.input_groups.values():
+            self.brian_net.add(value)
+        for value in self.neuron_groups.values():
+            self.brian_net.add(value)
+        for value in self.synapse_groups.values():
+            self.brian_net.add(value)
+        for value in self.spike_monitors.values():
+            self.brian_net.add(value)
+
+        # This is the scheduling of events needed for the synapse input not be discarded
+        # (the default handling of synapses occurs between thresholds and resets)
+        self.brian_net.schedule = ['start', 'groups', 'thresholds', 'resets', 'synapses', 'end']
+    
+    # Collect any output from the simulation
+    def read_spikes(self):
+        self.spike_list = []
+        offset = 0
+        for name, monitor in self.spike_monitors.items():
+            self.spike_list.extend([[] for _ in range(self.group_count[name])])
+            for s in range(len(monitor)):
+                self.spike_list[offset+monitor.i[s]].append(monitor.t[s]/ms)
+            offset += self.group_count[name]
+        
+        return self.spike_list
+        
+    # Return spikes as event list
+    def get_spikes(self):
+        if self.spike_list is None:
+            return self.read_spikes()
+        else:
+            return self.spike_list
+    
+    def plot_spikes(self, figsize=(8,6), linelengths=0.8, linewidths=1.0,
+                    color_dict={'LIF': 'C0', 'IN': 'C1'}, tick_names=False):
+        if self.spike_list is None:
+            self.read_spikes()
+            
+        # Plot the event list information
+        plt.figure(figsize=figsize)
+
+        # We can also color the rows according to population
+        if color_dict is None:
+            color_dict = {key: f"C{i%10}" for i, key in enumerate(self.group_count.keys())}
+        event_color = []
+        for name, count in self.group_count.items():
+            if name not in color_dict:
+                color_dict[name] = f"C{len(color_dict)%10}"
+            event_color.extend([color_dict[name]] * count)
+        # colored lines (for legend)
+        for key in color_dict.keys():
+            plt.plot(0,0,'-',color=color_dict[key],linewidth=2.0)
+        
+        # The spike raster is plotted using eventplot
+        plt.eventplot(self.spike_list, colors=event_color, lineoffsets=1,
+                      linelengths=linelengths, linewidths=linewidths)
+
+        # Tick names (may be too crowded with many neurons)
+        if tick_names:
+            plt.yticks(list(self.node_map.values()), list(self.node_map.keys()))
+        
+        plt.title('Spike Raster')
+        plt.xlabel('Time (ms)')
+        plt.ylabel('Neuron (index)')
+        plt.tight_layout()
+        plt.legend(color_dict.keys())

sango/backend/brian/registry/base.py

@@ -0,0 +1,26 @@
+# Base model registry
+model_registry = {'IN':  {'graph_type': 'input', 'state': {}},
+                  'LIF': {'graph_type': 'neuron',
+                          'model_eqs' : '''v : 1
+                                           v_thresh : 1
+                                           v_reset : 1
+                                           v_bias : 1
+                                           v_leak : 1
+                                        ''',
+                          'method'    : 'exact',
+                          'threshold' : 'v>v_thresh',
+                          'reset'     : 'v=v_reset',
+                          'events'    : {},
+                          'run_regularly' : [{'eqs': 'v*=(1.0-v_leak)', 'when': 'resets'},
+                                             {'eqs': 'v+=v_bias',       'when': 'groups'}],
+                          'state': {'v':        {'dsl': 'voltage',   'default': 0.0},
+                                    'v_thresh': {'dsl': 'threshold', 'default': 1.0},
+                                    'v_reset':  {'dsl': 'reset',     'default': 0.0},
+                                    'v_bias':   {'dsl': 'bias',      'default': 0.0},
+                                    'v_leak':   {'dsl': 'leak',      'default': 1.0}}},
+                  'PSP': {'graph_type': 'synapse',
+                          'model_eqs' : 'weight : 1',
+                          'on_pre'    : 'v+=weight',
+                          'state': {'delay':    {'dsl': 'delay',     'default': 1.0, 'unit': 'ms'},
+                                    'weight':   {'dsl': 'weight',    'default': 1.0}}}
+                 }

sango/backend/brian/registry/prob.py

@@ -0,0 +1,23 @@
+# Model registry
+model_registry = {'pLIF': {'graph_type': 'neuron',
+                           'model_eqs' : '''v : 1
+                                            v_thresh : 1
+                                            v_reset : 1
+                                            v_bias : 1
+                                            v_leak : 1
+                                            p_spike : 1
+                                         ''',
+                           'method'    : 'exact',
+                           'threshold' : '(v>v_thresh) and (rand()<=p_spike)',
+                           'reset'     : '', # probabilistic spiking requires custom event
+                           'events'    : {'pass_thresh': 'v>v_thresh'},
+                           'run_regularly' : [{'eqs': 'v*=(1.0-v_leak)', 'when': 'resets'},
+                                              {'eqs': 'v+=v_bias',       'when': 'groups'}],
+                           'run_on_event'  : [{'event': 'pass_thresh', 'eqs': 'v=v_reset'}],
+                           'state': {'v':        {'dsl': 'voltage',   'default': 0.0},
+                                     'v_thresh': {'dsl': 'threshold', 'default': 1.0},
+                                     'v_reset':  {'dsl': 'reset',     'default': 0.0},
+                                     'v_bias':   {'dsl': 'bias',      'default': 0.0},
+                                     'v_leak':   {'dsl': 'leak',      'default': 1.0},
+                                     'p_spike':  {'dsl': 'prob',      'default': 1.0}}}
+                 }

sango/backend/fugu/fugu.py

@@ -0,0 +1,267 @@
+import os
+import sys
+from pathlib import Path
+import importlib.util
+
+try:
+	import fugu
+except ImportError:
+	fugu = None
+if fugu is not None:
+    from fugu import Scaffold
+    from fugu.scaffold import PortData, ChannelData
+    from fugu.backends import snn_Backend
+
+import time
+from collections import Counter, defaultdict
+
+import numpy as np
+import networkx as nx
+import matplotlib.pyplot as plt
+
+class SimFugu:
+    def __init__(self, dsl_net):
+        if fugu is None:
+            raise ImportError("fugu package is required for SimFugu")
+        
+        self.dsl_net = dsl_net
+        self.timesteps = None
+        
+        self.node_map = None
+        self.spike_list = None
+    
+        self.model_registry = self.import_registry()
+
+        self.fugu_backend = None
+        self.debug = None
+        self.backend_args = None
+        self.scaffold = None
+    
+    # Dynamically import the model registry files
+    def import_registry(self):
+        registry = dict()
+        registry_dir = Path(__file__).resolve().parent / 'registry'
+        sys.path.insert(0, str(registry_dir.parent))
+        for file_path in registry_dir.glob("*.py"):
+            if file_path.name == "__init__.py":
+                continue
+            module_name = f"registry.{file_path.stem}"
+            spec = importlib.util.spec_from_file_location(module_name, file_path)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            registry.update(getattr(module, 'model_registry', {}))
+        sys.path.pop(0)
+        return registry
+    
+    # Convert between dsl model to Fugu model
+    def rekey_model(self, data):
+        for key, value in self.model_registry[data['model']]['param'].items():
+            if value['dsl'] is not None:
+                if value['dsl'] == 'delay':
+                    data[key] = int(data.pop(value['dsl']))
+                else:
+                    data[key] = data.pop(value['dsl'])
+            else:
+                data[key] = value['default']
+        return data
+        
+    def compile(self, backend='snn', backend_args={'record': 'all'}, debug=False):
+        self.debug = debug
+        if backend == 'snn':
+            self.fugu_backend = snn_Backend()
+        else:
+            raise NotImplementedError(f"Backend '{backend}' is not supported.")
+        self.backend_args = backend_args
+        if self.debug:
+            self.backend_args['debug_mode'] = True
+        
+        # Convert network to Fugu
+        start_time = time.perf_counter()
+        self.to_fugu()
+        end_time = time.perf_counter()
+        self.compile_time = end_time - start_time
+        if self.debug:
+            print(f"Compile time: {self.compile_time}")
+    
+    # Run the network
+    def run(self, timesteps=10.0, verbose=False):
+        self.timesteps = int(timesteps)
+        self.verbose = verbose
+
+        # Run network
+        start_time = time.perf_counter()
+        self.fugu_result = self.fugu_backend.run(n_steps=timesteps)
+        end_time = time.perf_counter()
+        self.run_time = end_time - start_time
+        if self.verbose:
+            print(f"Run time: {self.run_time}")
+    
+    # Translates a Sango network into a Fugu Scaffold
+    def to_fugu(self):
+        # Get a flattened graph object
+        self.dsl_graph = self.dsl_net._topology.to_nx()
+
+        # Convert networkx to scaffold and graph
+        self.scaffold = self.to_scaffold(self.dsl_graph)
+
+        # Compile scaffold in Fugu backend
+        self.fugu_backend.compile(self.scaffold, self.backend_args)
+
+    # Dummy brick object for Fugu scaffold
+    class DummyBrick():
+        def __init__(self, name='dummy'):
+            self.name = name
+            self.vector = []
+            self.index = 0
+            self.is_built = True
+        # This object is mainly used for managing Fugu inputs
+        def __iter__(self):
+            self.index = 0
+            return iter(self.vector)
+        def __next__(self):
+            if self.index < len(self.data):
+                result = self.vector[self.index]
+                self.index += 1
+                return result
+            else:
+                raise StopIteration
+
+    # Convert Sango network to Fugu Scaffold
+    def to_scaffold(self, net):
+        # Set up a dummy scaffold in Fugu
+        scaffold = Scaffold()
+        scaffold_circuit = nx.DiGraph()
+        # Input and main Sango bricks
+        input_brick = {'tag': 'input',
+                       'name': 'InputBrick',
+                       'brick': self.DummyBrick('input'),
+                       'layer': 'input',
+                       'ports': {'output': None},
+                       'is_built': True}
+        sango_brick = {'tag': 'sango',
+                       'name': 'SangoBrick',
+                       'brick': self.DummyBrick('sango'),
+                       'layer': 'output',
+                       'ports': {'input': None},
+                       'is_built': True}
+        # Connect dummy circuit
+        scaffold_circuit.add_node(0, **input_brick)
+        scaffold_circuit.add_node(1, **sango_brick)
+        scaffold_circuit.add_edge(0, 1, bind={'input': 'output'})
+        scaffold.tag_to_name = {'input': 'InputBrick', 'sango': 'SangoBrick'}
+        scaffold.brick_to_number = {'InputBrick': 0, 'SangoBrick': 1}
+
+        # Set up underlying graph
+        scaffold_graph = nx.DiGraph()
+        self.num_nodes = self.dsl_graph.number_of_nodes()
+        self.node_data = [dict() for _ in range(self.num_nodes)]
+        self.node_index = dict()
+        self.group_count = Counter()
+        self.local_index = [0 for _ in range(self.num_nodes)]
+        self.group_count['IN'] = 0
+        self.spike_input = dict()
+
+        # Global node data
+        for n, (node, data) in enumerate(self.dsl_graph.nodes(data=True)):
+            self.node_index[node] = n
+            self.node_data[n] = self.rekey_model(data)
+            self.group_count.update([self.node_data[n]['model']])
+            self.local_index[n] = self.group_count[self.node_data[n]['model']] - 1
+            # Add spike times for inputs
+            if self.model_registry[self.node_data[n]['model']]['node_class'] == 'InputNeuron':
+                self.spike_input[node]=data['times']
+        
+        # Remove the input model (IN) if counts are zero
+        if self.group_count['IN'] == 0:
+            del self.group_count['IN']
+        
+        # Get the model insertion order of our counter, and organize node map by group
+        self.group_index = {key: index for index, key in enumerate(self.group_count.keys())}
+        self.group_sorted_count = [self.group_count[group] for group in self.group_index]
+        self.group_offset = [0] + [sum(self.group_sorted_count[:i+1]) for i in range(len(self.group_sorted_count))]
+        self.node_map = {key: self.group_offset[self.group_index[self.node_data[n]['model']]] + self.local_index[n]
+                         for key, n in self.node_index.items()}
+
+        # Attach spike times to input brick
+        spike_times = defaultdict(list)
+        for n, (neuron, times) in enumerate(self.spike_input.items()):
+            for t in times:
+                spike_times[t].append(neuron)
+        spike_vector = [spike_times[key] for key in range(max(spike_times.keys())+1)]
+        scaffold_circuit.nodes[0]['brick'].vector = spike_vector
+        scaffold_circuit.nodes[0]['ports']['output'] = PortData(spec=None,
+            channels = {'data': ChannelData(spec=None, neurons = list(self.spike_input.keys()))})
+        scaffold_circuit.nodes[1]['ports']['input'] = PortData(spec=None,
+            channels = {'data': ChannelData(spec=None, neurons = [])})
+        scaffold.circuit = scaffold_circuit
+
+        # Insert nodes by group
+        for n, (node, nidx) in enumerate(self.node_map.items()):
+            node_data = self.node_data[n]
+            if node_data['model'] == 'IN':
+                scaffold_graph.add_node(node, neuron_number=nidx,
+                                        brick='InputBrick', **node_data)
+            else:
+                scaffold_graph.add_node(node, neuron_number=nidx,
+                                        brick='SangoBrick', **node_data)
+        
+        # Global edge data
+        for source, target, data in self.dsl_graph.edges(data=True):
+            edge_data = self.rekey_model(data)
+            scaffold_graph.add_edge(source, target, **edge_data)
+        
+        # Attach the built graph to the scaffold and mark as built
+        scaffold.graph = scaffold_graph
+        scaffold.is_built = True
+
+        return scaffold
+
+    # Collect any output from the simulation
+    def read_spikes(self):
+        # Reading in Fugu's dataframe results
+        spike_dict = defaultdict(list)
+        for spike in self.fugu_result.itertuples(index=False):
+            spike_dict[int(spike.neuron_number)].append(spike.time)
+        self.spike_list = [spike_dict[key] for key in range(len(self.node_map))]
+        return self.spike_list
+        
+    # Return spikes as event list
+    def get_spikes(self):
+        if self.spike_list is None:
+            return self.read_spikes()
+        else:
+            return self.spike_list
+
+    def plot_spikes(self, figsize=(8,6), linelengths=0.8, linewidths=1.0,
+                    color_dict={'LIF': 'C0', 'IN': 'C1'}, tick_names=False):
+        if self.spike_list is None:
+            self.read_spikes()
+            
+        # Plot the event list information
+        plt.figure(figsize=figsize)
+
+        # We can also color the rows according to population
+        if color_dict is None:
+            color_dict = {key: f"C{i%10}" for i, key in enumerate(self.group_count.keys())}
+        event_color = []
+        for name, count in self.group_count.items():
+            if name not in color_dict:
+                color_dict[name] = f"C{len(color_dict)%10}"
+            event_color.extend([color_dict[name]] * count)
+        # colored lines (for legend)
+        for key in color_dict.keys():
+            plt.plot(0,0,'-',color=color_dict[key],linewidth=2.0)
+        
+        # The spike raster is plotted using eventplot
+        plt.eventplot(self.spike_list, colors=event_color, lineoffsets=1,
+                      linelengths=linelengths, linewidths=linewidths)
+
+        # Tick names (may be too crowded with many neurons)
+        if tick_names:
+            plt.yticks(list(self.node_map.values()), list(self.node_map.keys()))
+        
+        plt.title('Spike Raster')
+        plt.xlabel('Time (ms)')
+        plt.ylabel('Neuron (index)')
+        plt.tight_layout()
+        plt.legend(color_dict.keys())

sango/backend/fugu/registry/base.py

@@ -0,0 +1,15 @@
+# Base model registry
+model_registry = {
+    'LIF': {'node_class': 'LIFNeuron',
+            'param': {'threshold': {'dsl': 'threshold', 'default': 0.0},
+                      'reset_voltage': {'dsl': 'reset', 'default': 0.0},
+                      'decay': {'dsl': 'leak', 'default': 1.0},
+                      'voltage': {'dsl': 'voltage', 'default': 0.0},
+                      'bias': {'dsl': 'bias', 'default': 0.0}}},
+    'IN': {'node_class': 'InputNeuron',
+           'param': {'threshold': {'dsl': None, 'default': 0.1},
+                     'voltage': {'dsl': None, 'default': 0.0}}},
+    'PSP': {'edge_class': 'Synapse',
+            'param': {'weight': {'dsl': 'weight', 'default': 1.0},
+                      'delay': {'dsl': 'delay', 'default': 1.0}}}
+}

sango/backend/fugu/registry/prob.py

@@ -0,0 +1,10 @@
+# Prob model registry
+model_registry = {
+    'pLIF': {'node_class': 'LIFNeuron',
+             'param': {'threshold': {'dsl': 'threshold', 'default': 0.0},
+                       'reset_voltage': {'dsl': 'reset', 'default': 0.0},
+                       'decay': {'dsl': 'leak', 'default': 1.0},
+                       'voltage': {'dsl': 'voltage', 'default': 0.0},
+                       'p': {'dsl': 'prob', 'default': 1.0},
+                       'bias': {'dsl': 'bias', 'default': 0.0}}}
+}