yinspire 0.1.0

data/lib/Yinspire/Core/Simulator.rb

@@ -0,0 +1,36 @@
+require 'Yinspire/Core/NeuralEntity'
+require 'Yinspire/Core/Scheduling/Simulator'
+
+class Simulator
+
+  #
+  # The tolerance (time difference) up to which local stimuli are
+  # accumulated.
+  #
+  property :stimuli_tolerance, 'simtime', :init => Infinity
+
+  #
+  # Statistics counter
+  #
+  property :event_counter, 'uint'
+  property :fire_counter, 'uint'
+
+  stub_method :record_fire, {:at => 'simtime'},{:weight => 'real'},{:source => NeuralEntity}
+
+  #
+  # Overwrite!
+  #
+  def record_fire(at, weight, source)
+  end
+
+  attr_reader :entities
+
+  def initialize
+    @entities = Hash.new
+  end
+
+  def run(stop_at=nil)
+    schedule_run(stop_at || Infinity)
+  end
+ 
+end

data/lib/Yinspire/Core/StimuliMixin.rb

@@ -0,0 +1,103 @@
+require 'Yinspire/Core/Stimulus'
+
+#
+# Module contains code to store local stimuli in a priority queue. Used
+# by several Neuron models.
+#
+module StimuliMixin; cplus2ruby
+
+  #
+  # Each NeuralEntity has it's own local stimuli priority queue.
+  # Neurons make use of this whereas Synapses do not.
+  #
+  # Nevertheless we put this into the base class for simplicity reasons
+  # and as it's quite low overhead (12 bytes).
+  #
+  property :stimuli_pq, 'BinaryHeap<Stimulus, MemoryAllocator<Stimulus> >'
+
+  #
+  # Returns a Ruby array in the form [at1, weight1, at2, weight2] 
+  # for +stimuli_pq+.
+  #
+  method :stimuli_pq_to_a, {:returns => Object}, %{
+    VALUE ary = rb_ary_new(); 
+    @stimuli_pq.each(Stimulus::dump_to_a, &ary);
+    return ary;
+  }
+
+  # 
+  # Add a Stimuli to the local priority queue.
+  #
+  method :stimuli_add, {:at => 'simtime'},{:weight => 'real'}, %{
+    Stimulus s; s.at = at; s.weight = weight;
+
+    if (@simulator->stimuli_tolerance >= 0.0)
+    {
+      Stimulus *parent = @stimuli_pq.find_parent(s);
+
+      if (parent != NULL && (s.at - parent->at) <= @simulator->stimuli_tolerance)
+      {
+        parent->weight += s.weight;
+        return;
+      }
+    }
+    
+    @stimuli_pq.push(s);
+    schedule(@stimuli_pq.top().at);
+  }
+
+  # 
+  # Consume all Stimuli until +till+ and return the sum of the weights.
+  #
+  method :stimuli_sum, {:till => 'simtime'},{:returns => 'real'}, %{
+    real weight = 0.0;
+
+    while (!@stimuli_pq.empty() && @stimuli_pq.top().at <= till)
+    {
+      weight += @stimuli_pq.top().weight;
+      @stimuli_pq.pop();
+    }
+
+    /*
+     * NOTE: we don't have to remove the entity from the schedule if the
+     * pq is empty.
+     */
+    if (!@stimuli_pq.empty())
+    {
+      schedule(@stimuli_pq.top().at);
+    }
+
+    return weight;
+  }
+
+  #
+  # Consume all Stimuli until +till+ and return the sum of the weights.
+  # This treats infinitive values specially and instead of summing them,
+  # it sets +is_inf+ to +true+.
+  #
+  method :stimuli_sum_inf, {:till => 'simtime'},{:is_inf => 'bool&'},{:returns => 'real'}, %{
+    real weight = 0.0;
+    is_inf = false;
+
+    while (!@stimuli_pq.empty() && @stimuli_pq.top().at <= till)
+    {
+      if (isinf(@stimuli_pq.top().weight))
+      {
+        is_inf = true;
+      }
+      else
+      {
+        weight += @stimuli_pq.top().weight;
+      }
+      @stimuli_pq.pop();
+    }
+
+    if (!@stimuli_pq.empty())
+    {
+      schedule(@stimuli_pq.top().at);
+    }
+
+    return weight;
+  }
+
+end

data/lib/Yinspire/Core/Stimulus.rb

@@ -0,0 +1,25 @@
+# 
+# The data structure used for storing a fire impluse or any other form
+# of stimulation.
+#
+class Stimulus
+
+  cplus2ruby :no_wrap => true
+  cplus2ruby :order => -1 
+
+  property :at, :simtime
+  property :weight, :real
+
+  static_method :less, {:a => 'const Stimulus&'}, {:b => 'const Stimulus&'}, {:returns => 'bool'}, %{
+    return (a.at < b.at);
+  }, :inline => true
+
+  #
+  # Appends +at+ and +weight+ to the Ruby array passed as +ary+.
+  #
+  static_method :dump_to_a, {:s => 'const Stimulus&'},{:ary => 'void*'}, %{
+    rb_ary_push(*((VALUE*)ary), rb_float_new(s.at));
+    rb_ary_push(*((VALUE*)ary), rb_float_new(s.weight));
+  }
+
+end

data/lib/Yinspire/Core/Synapse.rb

@@ -0,0 +1,64 @@
+require 'Yinspire/Core/NeuralEntity'
+require 'Yinspire/Core/Neuron'
+
+#
+# Base class of all Synapses. Defines the structure that is special for
+# a Synapse, i.e. that a Synapse has a pre and a post-Neuron.  Also
+# each Synapse has a +weight+ and a +delay+.
+#
+class Synapse < NeuralEntity
+
+  property :pre_neuron, Neuron
+  property :post_neuron, Neuron
+  
+  #  
+  # Those pointers are part of an internal linked-list that
+  # starts at a Neuron and connects all pre-synapses of an Neuron
+  # together. In the same way it connects all post-synapses of an
+  # Neuron together.
+  #
+  property :next_pre_synapse, Synapse
+  property :next_post_synapse, Synapse
+  property :prev_pre_synapse, Synapse
+  property :prev_post_synapse, Synapse
+
+  # 
+  # The fire weight of a Synapse.
+  #
+  property :weight, 'real', :marshal => true
+
+  # 
+  # The propagation delay of a Synapse.
+  #
+  property :delay, 'simtime', :marshal => true
+
+  # 
+  # Adding a pre synapse. Target must be a Neuron.
+  #
+  def connect(target)
+    target.add_pre_synapse(self)
+  end
+
+  def disconnect(target)
+    target.delete_pre_synapse(self)
+  end
+
+  def each_connection
+    yield self.post_neuron
+  end
+
+  # 
+  # Only propagate the stimulation if it doesn't originate from the
+  # post Neuron.  Stimuli from a post Neuron are handled by a specific
+  # Synapse class (e.g. Hebb).
+  # 
+  # NOTE: We ignore the weight parameter that is passed by the Neuron.
+  #
+  method :stimulate, {:at => 'simtime'},{:weight => 'real'},{:source => NeuralEntity}, %{
+    if (source != @post_neuron)
+    {
+      @post_neuron->stimulate(at + @delay, @weight, this);
+    }
+  }
+
+end

data/lib/Yinspire/Dumpers/Dumper.rb

@@ -0,0 +1,19 @@
+#
+# Common super class of all Dumpers.
+#
+class Dumper
+
+  def initialize(simulator)
+    @simulator = simulator
+    @entities = @simulator.entities
+  end
+
+  def dump_entities
+    entities = {}
+    @entities.each {|id, entity|
+      entities[id] = [entity.entity_type || raise, entity.dump]  
+    }
+    entities
+  end
+
+end

data/lib/Yinspire/Dumpers/Dumper_Dot.rb

@@ -0,0 +1,28 @@
+require 'Yinspire/Dumpers/Dumper'
+
+#
+# Dumper for the GraphViz[1] dot format.
+#
+# Only dumps the net, not the stimulis.
+#
+# [1]: http://www.graphviz.org/
+#
+class Dumper_Dot < Dumper
+
+  #
+  # NOTE: Unconnected synapses are not shown.
+  #
+  def dump(out)
+    out << "digraph {\n"
+    out << "node [shape = circle];\n"
+
+    @entities.each_value {|entity|
+      next unless entity.kind_of?(Neuron) 
+      entity.each_connection do |syn|
+        out << "#{entity.id.inspect} -> #{syn.post_neuron.id.inspect} [label = #{syn.id.inspect} ];\n"
+      end
+    }
+    out << "}\n"
+  end
+
+end

data/lib/Yinspire/Loaders/GraphML.rb

@@ -0,0 +1,84 @@
+require 'rexml/document'
+
+class GraphML
+
+  class Graph < Struct.new(:id, :data, :nodes, :edges); end
+  class Node < Struct.new(:id, :data); end
+  class Edge < Struct.new(:id, :data, :source, :target); end
+
+  attr_reader :graphs
+
+  def self.parse(io)
+    doc = REXML::Document.new(io)
+    new().parse(doc)
+  end
+
+  def initialize
+    @keys = Hash.new
+    @graphs = Hash.new
+    @ids = Hash.new
+  end
+
+  def parse(doc)
+    parse_keys(doc.root)
+    parse_graphs(doc.root)
+    return self
+  end
+
+  private 
+
+  def check_id(id)
+    raise "duplicate id: #{ id }" if @ids.has_key?(id)
+    @ids[id] = true
+    id
+  end
+
+  def parse_keys(root)
+    root.elements.each('key') do |el|
+      id = check_id(el.attributes['id'])
+      (@keys[el.attributes['for']] ||= {})[id] = true
+    end
+  end
+
+  def parse_graphs(root)
+    root.elements.each('graph') do |g|
+      graph = GraphML::Graph.new
+      graph.id = check_id(g.attributes['id'])
+      graph.data = parse_data(g, 'graph')
+      graph.nodes = Hash.new
+      graph.edges = Hash.new
+      @graphs[graph.id] = graph
+
+      g.elements.each('node') do |el|
+        node = GraphML::Node.new
+        node.id = check_id(el.attributes['id'])
+        node.data = parse_data(el, 'node')
+        graph.nodes[node.id] = node
+      end
+
+      g.elements.each('edge') do |el|
+        # FIXME: for now always assume directed edges
+        edge = GraphML::Edge.new
+        edge.id = check_id(el.attributes['id'])
+        edge.source = graph.nodes[el.attributes['source']] || raise
+        edge.target = graph.nodes[el.attributes['target']] || raise
+        edge.data = parse_data(el, 'edge')
+        graph.edges[edge.id] = edge
+      end
+    end
+  end
+
+  def parse_data(root, for_el)
+    hash = Hash.new
+    root.elements.each('data') do |el|
+      key, value = el.attributes['key'], el.text
+      raise unless @keys[for_el][key]
+      hash[key] = value
+    end
+    hash
+  end
+end
+
+if __FILE__ == $0
+  p GraphML.parse(File.open("../../../examples/nets/skorpion.graphml"))
+end

data/lib/Yinspire/Loaders/Loader.rb

@@ -0,0 +1,31 @@
+#
+# Common super class of all Loaders.
+#
+# Uses Cplus2Ruby property annotations to automatically assign
+# properties:
+#
+#   property :name, :marshal => true, :init => 123
+#
+class Loader
+
+  def initialize(simulator)
+    @simulator = simulator
+    @entities = @simulator.entities
+  end
+
+  protected
+
+  #
+  # Create an object with id +id+ of class +entity_type+, where
+  # +entity_type+ is a string.
+  #
+  # Argument +data+ is a hash that contains the property values.
+  #
+  def create_entity(entity_type, id, data)
+    entity = NeuralEntity.new_from_name(entity_type, id, @simulator)
+    entity.load(data)
+    raise if @entities[id]
+    @entities[id] = entity
+  end
+
+end

data/lib/Yinspire/Loaders/Loader_GraphML.rb

@@ -0,0 +1,97 @@
+#
+# Load a neuronal net from GraphML format.
+#
+# Copyright (c) 2007, 2008 by Michael Neumann (mneumann@ntecs.de)
+#
+
+require 'Yinspire/Loaders/Loader'
+require 'Yinspire/Loaders/GraphML'
+
+class Loader_GraphML < Loader
+
+  TYPE_MAP = {
+    'NEURONTYPE_KBLIF' => 'Neuron_SRM01',
+    'NEURONTYPE_EKERNEL' => 'Neuron_SRM02',
+    'SYNAPSE_DEFAULT' => 'Synapse',
+    'SYNAPSE_HEBB' => 'Synapse_Hebb'
+  }
+
+  PARAM_MAP = {
+    'absRefPeriod' => ['abs_refr_duration', 'real'],
+    'neuronLFT' => ['last_fire_time', 'real'],
+    'neuronLSET' => ['last_spike_time', 'real'],
+    'neuron_tauM' => ['tau_m', 'real'],
+    'neuron_tauRef' => ['tau_ref', 'real'],
+    'neuron_constThreshold' => ['const_threshold', 'real'],
+    'neuron_refWeight' => ['ref_weight', 'real'],
+    'neuron_arpTime' => ['abs_refr_duration', 'real'],
+    'synapse_weight' => ['weight', 'real'],
+    'synapse_delay' => ['delay', 'real'],
+    'neuronPSP' => ['mem_pot', 'real'],
+    'neuronReset' => ['reset', 'real'],
+    'neuron_tauM' => ['tau_m', 'real'],
+    'neuron_tauRecov' => ['tau_ref', 'real'],
+    'neuron_uReset' => ['u_reset', 'real'],
+    'neuron_threshold' => ['const_threshold', 'real']
+  }
+
+  def load(file)
+    File.open(file) do |f|
+      gml = GraphML.parse(f)
+      g = gml.graphs.values.first
+      default_neuron_type = g.data['graph_default_neuron_type']
+      default_synapse_type = g.data['graph_default_synapse_type']
+
+      #
+      # Create Neurons
+      #
+      g.nodes.each_value {|node|
+        create(node.id, node.data, default_neuron_type, 'neuron_type')
+      }
+
+      # 
+      # Create Synapses
+      #
+      g.edges.each_value {|edge|
+        create(edge.id, edge.data, default_synapse_type, 'synapse_type')
+      }
+
+      #
+      # Create Connections between Neurons and Synapses.
+      #
+      g.edges.each_value {|edge|
+        a = @entities[edge.source.id] || raise
+        b = @entities[edge.id] || raise
+        c = @entities[edge.target.id] || raise
+        a.connect(b)
+        b.connect(c)
+      }
+    end
+  end
+
+  protected
+
+  #
+  # Parameter +kind+ is either of "neuron_type" or "synapse_type".
+  #
+  def create(id, data, default_type, kind)
+    entity_type = (TYPE_MAP[data[kind] || default_type] || raise)
+    data.delete(kind)
+    create_entity(entity_type, id, conv_params(data))
+  end
+
+  def conv_params(data)
+    hash = {}
+    data.each {|k,v|
+      name, type = PARAM_MAP[k] || raise
+      case type
+      when 'real'
+        hash[name] = v.strip.to_f
+      else
+        raise
+      end
+    }
+    return hash
+  end
+
+end