yinspire 0.1.0

data/lib/Yinspire/All.rb

@@ -0,0 +1,10 @@
+require 'Yinspire/Models/Neuron_Input'
+require 'Yinspire/Models/Neuron_Output'
+require 'Yinspire/Models/Neuron_SRM01'
+require 'Yinspire/Models/Neuron_SRM02'
+require 'Yinspire/Models/Synapse_Hebb'
+require 'Yinspire/Loaders/Loader_JSON'
+require 'Yinspire/Loaders/Loader_GraphML'
+require 'Yinspire/Loaders/Loader_Yin'
+require 'Yinspire/Loaders/Loader_Spike'
+require 'Yinspire/Dumpers/Dumper_Dot'

data/lib/Yinspire/Core/NeuralEntity.rb

@@ -0,0 +1,133 @@
+require 'Yinspire/Core/Simulator'
+require 'Yinspire/Core/Scheduling/NeuralEntity'
+
+#
+# NeuralEntity is the base class of all entities in a neural net, i.e.
+# Neurons and Synapses.
+#
+class NeuralEntity
+
+  #
+  # Entity type name to class mapping. 
+  #
+  @@entity_type_map = Hash.new
+  def self.entity_type_map() @@entity_type_map end
+
+
+  #
+  # Entity class to type name mapping.
+  #
+  @@entity_type_map_reverse = Hash.new
+  def self.entity_type_map_reverse() @@entity_type_map_reverse end
+
+  def entity_type() @@entity_type_map_reverse[self.class] end
+
+  #
+  # Annotation cache for loading entities.
+  #
+  @@entity_ann_load_cache = Hash.new
+  def self.entity_ann_load_cache() @@entity_ann_load_cache end
+
+  #
+  # Annotation cache for dumping entities.
+  #
+  @@entity_ann_dump_cache = Hash.new
+  def self.entity_ann_dump_cache() @@entity_ann_dump_cache end
+
+  def self.new_from_name(name, *args, &block)
+    (@@entity_type_map[name] || raise(ArgumentError)).new(*args, &block)
+  end
+
+  def self.class_from_name(name)
+    (@@entity_type_map[name] || raise(ArgumentError))
+  end
+
+  def load(hash)
+    a = @@entity_ann_load_cache[self.class]
+    hash.each {|key, value|
+      if meth = a[key]
+        send(meth, value)
+      end
+    }
+  end
+
+  def dump
+    hash = Hash.new
+    @@entity_ann_dump_cache[self.class].each {|key|
+      hash[key] = send(key)
+    }
+    hash
+  end
+
+  def initialize(id=nil, simulator=nil, &block)
+    self.id = id
+    self.simulator = simulator
+    block.call(self) if block
+  end
+
+  #
+  # Each NeuralEntity has an +id+ associated which uniquely identifies
+  # itself within a Simulator instance. This +id+ is usually assigned by the
+  # Simulator (during loading or constructing a neural net) and SHOULD
+  # NOT be changed afterwards (because it's used as a key in a Hash).
+  #
+  property :id
+
+  #
+  # Each NeuralEntity has a reference back to the Simulator. This is
+  # used for example to update it's scheduling or to report a fire
+  # event.
+  #
+  # Like +id+, this is assigned by the Simulator.
+  #
+  property :simulator, Simulator
+
+  #
+  # Connect +self+ with +target+.
+  #
+  def connect(target) raise "abstract method" end
+
+  #
+  # Disconnect +self+ from all connections.
+  #
+  def disconnect(target) raise "abstract method" end
+
+  #
+  # Iterates over each connection. To be overwritten by subclasses!
+  #
+  def each_connection() raise "abstract method" end
+ 
+  #
+  # Disconnect +self+ from all connections.
+  #
+  def disconnect_all
+    each_connection {|conn| disconnect(conn) }
+  end
+
+  virtual :stimulate, :process, :process_stepped
+
+  #
+  # Stimulate an entity +at+ a specific time with a specific +weight+
+  # and from a specific +source+.
+  #
+  # Overwrite!
+  #
+  method :stimulate, {:at => 'simtime'},{:weight => 'real'},{:source => NeuralEntity}, nil
+
+  #
+  # This method is called when a NeuralEntity reaches it's scheduling
+  # time.
+  #
+  # Overwrite if you need this behaviour!
+  #
+  method :process, {:at => 'simtime'}, nil
+
+  #
+  # This method is called in each time-step, if and only if a
+  # NeuralEntity had enabled stepped scheduling.
+  #
+  # Overwrite if you need this behaviour!
+  #
+  method :process_stepped, {:at => 'simtime'},{:step => 'simtime'}, nil
+
+end

data/lib/Yinspire/Core/Neuron.rb

@@ -0,0 +1,162 @@
+require 'Yinspire/Core/NeuralEntity'
+require 'Yinspire/Core/Synapse'
+
+#
+# Base class of all Neurons. Defines the structure that is special for a
+# Neuron, i.e. that a Neuron has pre- and post-Synapses.
+#
+class Neuron < NeuralEntity
+
+  property :first_pre_synapse, Synapse
+  property :first_post_synapse, Synapse
+  property :last_pre_synapse, Synapse
+  property :last_post_synapse, Synapse
+
+  def add_pre_synapse(syn)
+    raise ArgumentError, "Synapse expected" unless syn.kind_of?(Synapse)
+    raise "Synapse already connected" if syn.post_neuron || syn.next_pre_synapse
+
+    if last = self.last_pre_synapse
+      assert(last.next_pre_synapse == nil) # missing method: neuron instead of synapse
+      last.next_pre_synapse = syn
+      self.last_pre_synapse = syn # advance tail pointer
+    else
+      assert(self.first_pre_synapse == nil)
+      self.first_pre_synapse = self.last_pre_synapse = syn
+    end
+
+    syn.post_neuron = self
+  end
+
+  def add_post_synapse(syn)
+    raise ArgumentError, "Synapse expected" unless syn.kind_of?(Synapse)
+    raise "Synapse already connected" if syn.pre_neuron || syn.next_post_synapse
+
+    if last = self.last_post_synapse
+      assert(last.next_post_synapse == nil)
+      last.next_post_synapse = syn
+      self.last_post_synapse = syn # advance tail pointer
+    else
+      assert(self.first_post_synapse == nil)
+      self.first_post_synapse = self.last_post_synapse = syn
+    end
+
+    syn.pre_neuron = self
+  end
+
+  def delete_pre_synapse(syn)
+    raise ArgumentError, "Synapse expected" unless syn.kind_of?(Synapse)
+    raise "Synapse not connected to this Neuron" if syn.post_neuron != self
+
+    prev = find_preceding_synapse(syn, first_pre_synapse(), :next_pre_syapse)
+
+    #
+    # Remove +target+ from linked list.
+    #
+    if prev
+      prev.next_pre_synapse = target.next_post_synapse
+      self.last_post_synapse = prev if self.last_post_synapse == target 
+    else
+      #
+      # target is the only synapse in the post synapse list.
+      #
+      assert self.first_post_synapse == target
+      assert self.last_post_synapse == target
+      self.first_post_synapse = nil
+      self.last_post_synapse = nil
+    end
+
+    target.pre_neuron = nil
+    target.next_post_synapse = nil
+  end
+
+  def delete_post_synapse(syn)
+    # FIXME
+    raise "target must be Synapse" unless target.kind_of?(Synapse)
+    raise "Synapse not connected to this Neuron" if target.pre_neuron != self 
+
+    #
+    # Find the synapse in the linked list that precedes +target+.
+    #
+    prev = nil
+    curr = self.first_post_synapse
+
+    while true
+      break if curr == target
+      break unless curr
+      prev = curr
+      curr = curr.next_post_synapse
+    end
+
+    raise "Synapse not in post synapse list" if curr != target
+
+    #
+    # Remove +target+ from linked list.
+    #
+    if prev
+      prev.next_post_synapse = target.next_post_synapse
+      self.last_post_synapse = prev if self.last_post_synapse == target 
+    else
+      #
+      # target is the only synapse in the post synapse list.
+      #
+      assert self.first_post_synapse == target
+      assert self.last_post_synapse == target
+      self.first_post_synapse = nil
+      self.last_post_synapse = nil
+    end
+
+    target.pre_neuron = nil
+    target.next_post_synapse = nil
+  end
+
+  alias connect add_post_synapse
+  alias disconnect delete_post_synapse
+  
+  #
+  # Iterates over each outgoing connection (post synapses).
+  # 
+  def each_connection
+    syn = self.first_post_synapse
+    while syn
+      yield syn
+      syn = syn.next_post_synapse
+    end
+  end
+
+  protected
+
+  #
+  # Find the synapse in the linked list that precedes +syn+, starting
+  # at synapse +first+ and using the +next_method+ chain (e.g.
+  # :next_pre_synapse or :next_post_synapse).
+  #
+  def find_preceding_synapse(syn, first, next_method)
+    prev, curr = nil, first
+
+    while true
+      break if curr == syn
+      break unless curr
+      prev = curr
+      curr = curr.send(next_method)
+    end
+
+    raise "Synapse not in pre synapse list" if curr != syn
+    return prev
+  end
+
+  method :stimulate_pre_synapses, {:at => 'simtime'}, {:weight => 'real'}, %{
+    for (Synapse *syn = @first_pre_synapse; syn != NULL; syn = syn->next_pre_synapse)
+    {
+      syn->stimulate(at, weight, this);
+    }
+  }
+
+  method :stimulate_post_synapses, {:at => 'simtime'}, {:weight => 'real'}, %{
+    for (Synapse *syn = @first_post_synapse; syn != NULL; syn = syn->next_post_synapse)
+    {
+      syn->stimulate(at, weight, this);
+    }
+  }
+
+end

data/lib/Yinspire/Core/Scheduling/NeuralEntity.rb

@@ -0,0 +1,123 @@
+#
+# Extends class NeuralEntity for methods related to 
+# scheduling.
+#
+class NeuralEntity
+
+  #
+  # The index of this entity in the entity priority queue managed by the
+  # Simulator. If +schedule_index+ is zero then the entity is currently
+  # not present in the priority queue and as such the entity is not
+  # scheduled at a specific time.
+  #
+  property :schedule_index, 'uint'
+
+  #
+  # If the entity has events in the future, this is the timestamp of the
+  # next event.
+  #
+  property :schedule_at, 'simtime', :init => Infinity
+
+  #
+  # If stepped scheduling is used, these two properties reference the
+  # previous/next entity in the stepped-scheduling list.
+  #
+  property :schedule_stepping_list_prev, NeuralEntity
+  property :schedule_stepping_list_next, NeuralEntity
+
+  # 
+  # To be able to modify the stepped scheduling list
+  # (schedule_stepping_list_prev/next) during stepped schedule
+  # processing, we build up an internal linked list that we use to
+  # traverse all entities that require stepped schedule processing. 
+  # 
+  # This is cheaper than using an externalized linked list, as we would
+  # have to allocate memory which we overcome with this approach.
+  # 
+  # This is only used by the simulator!
+  #
+  property :schedule_stepping_list_internal_next, NeuralEntity
+
+  #
+  # Schedule the entity at a specific time. Only schedule if the new
+  # schedule time is before the current schedule time.
+  #
+  method :schedule, {:at => 'simtime'}, %{
+    // FIXME: make sure that @schedule_at is 
+    // reset when entity is removed from pq!
+    if (at < @schedule_at)
+    {
+      @schedule_at = at;
+      @simulator->schedule_update(this);
+    }
+  }, :inline => true
+
+  # 
+  # Returns +true+ if stepped scheduling is enabled, +false+ otherwise.
+  #
+  method :schedule_stepping_enabled, {:returns => 'bool'}, %{
+    return (@schedule_stepping_list_prev != NULL && 
+            @schedule_stepping_list_next != NULL);
+  }
+
+  #
+  # Enables stepped scheduling.
+  #
+  method :schedule_enable_stepping, {}, %{
+    if (!schedule_stepping_enabled())
+    {
+      NeuralEntity*& root = @simulator->schedule_stepping_list_root; 
+      if (root != NULL)
+      {
+        @schedule_stepping_list_prev = root;
+        @schedule_stepping_list_next = root->schedule_stepping_list_next;
+        root->schedule_stepping_list_next = this; 
+        @schedule_stepping_list_next->schedule_stepping_list_prev = this; 
+      }
+      else
+      {
+        root = this; 
+        @schedule_stepping_list_prev = this;
+        @schedule_stepping_list_next = this;
+      }
+    }
+  }
+
+  #
+  # Disables stepped scheduling.
+  #
+  method :schedule_disable_stepping, {}, %{
+    if (schedule_stepping_enabled())
+    {
+      if (@schedule_stepping_list_prev != @schedule_stepping_list_next)
+      {
+        @schedule_stepping_list_prev->schedule_stepping_list_next = @schedule_stepping_list_next; 
+        @schedule_stepping_list_next->schedule_stepping_list_prev = @schedule_stepping_list_prev;  
+      }
+      else
+      {
+        /*
+         * We are the last entity in the stepping list.
+         */
+        @simulator->schedule_stepping_list_root = NULL;
+        @schedule_stepping_list_prev = NULL;
+        @schedule_stepping_list_next = NULL;
+      }
+    }
+  }
+
+  #
+  # Accessor function for BinaryHeap
+  #
+  static_method :less, {:a => NeuralEntity},{:b => NeuralEntity},{:returns => 'bool'}, %{
+    return (a->schedule_at < b->schedule_at);
+  }, :inline => true
+
+  #
+  # Accessor function for BinaryHeap
+  #
+  static_method :index, {:a => NeuralEntity},{:returns => 'uint&'}, %{
+    return a->schedule_index;
+  }, :inline => true
+
+end

data/lib/Yinspire/Core/Scheduling/Simulator.rb

@@ -0,0 +1,94 @@
+require 'Yinspire/Core/NeuralEntity'
+
+#
+# Extends class Simulator for methods related to 
+# scheduling.
+#
+class Simulator
+
+  #
+  # The current simulation time.
+  #
+  property :schedule_current_time, 'simtime'
+
+  #
+  # The time step used for stepped scheduling.
+  #
+  property :schedule_step, 'simtime', :init => Infinity
+
+  #
+  # The time of the next step.
+  #
+  property :schedule_next_step, 'simtime', :init => Infinity
+
+  #
+  # Priority queue used to schedule the entities.
+  #
+  property :schedule_pq, 'IndexedBinaryHeap<NeuralEntity*, MemoryAllocator<NeuralEntity*>, NeuralEntity>',
+    :mark => 'mark_schedule_pq()'
+
+  method :mark_schedule_pq, {}, %{
+    @schedule_pq.each(Simulator::mark_schedule_pq_iter, NULL);
+  }
+ 
+  static_method :mark_schedule_pq_iter, {:s => 'NeuralEntity* const&'}, {:ptr => 'void*'}, %{
+    if (s) rb_gc_mark(s->__obj__);
+  }
+
+  #
+  # If stepped scheduling is used, this points to the first entiy in the
+  # stepped schedule list.
+  #
+  property :schedule_stepping_list_root, NeuralEntity
+
+  #
+  # Run the simulation.
+  #
+  method :schedule_run, {:stop_at => 'simtime'}, %{
+    while (true)
+    {
+      simtime next_stop = MIN(stop_at, @schedule_next_step);
+
+      /* 
+       * Calculate all events from the priority queue until the next time
+       * step is reached.
+       */
+      while (!@schedule_pq.empty())
+      {
+        NeuralEntity *top = @schedule_pq.top();
+        if (top->schedule_at >= next_stop)
+          break;
+        @schedule_current_time = top->schedule_at; 
+        @schedule_pq.pop();
+        top->process(top->schedule_at);
+      }
+
+      if (@schedule_current_time >= stop_at)
+        break;
+
+      if (@schedule_stepping_list_root == NULL && @schedule_pq.empty())
+        break;
+
+      /* 
+       * Calculate the entities that require stepped processing.
+       */ 
+      @schedule_current_time = @schedule_next_step; 
+
+      if (@schedule_stepping_list_root != NULL)
+      {
+        // FIXME: collect all entities in an array. then process them.
+      }
+
+      @schedule_next_step += @schedule_step;
+    }
+  }
+
+  # 
+  # If an entity has changed it's scheduling time, it has to call this
+  # method to reflect the change within the priority queue.
+  #
+  method :schedule_update, {:entity => NeuralEntity}, %{
+    @schedule_pq.update(entity);
+  }, :inline => true
+
+end