yinspire 0.1.0

data/lib/Yinspire/Models/Neuron_Base.rb

@@ -0,0 +1,38 @@
+require 'Yinspire/Core/Neuron'
+require 'Yinspire/Core/StimuliMixin'
+
+class Neuron_Base < Neuron
+
+  include StimuliMixin
+  
+  #
+  # Duration of the absolute refraction period.
+  #
+  property :abs_refr_duration, 'simtime', :marshal => true
+
+  #
+  # Last spike time
+  #
+  property :last_spike_time, 'simtime', :init => -Infinity, :marshal => true
+  
+  #
+  # Last fire time
+  #
+  property :last_fire_time, 'simtime', :init => -Infinity, :marshal => true
+
+  #
+  # Whether this neuron is a hebb neuron or not.  A hebb neuron also
+  # stimulates it's pre synapses upon firing.
+  #
+  property :hebb, 'bool', :init => false, :marshal => true
+
+  method :stimulate_synapses, {:at => 'simtime'}, {:weight => 'real'}, %{
+    if (@hebb) stimulate_pre_synapses(at, weight);
+    stimulate_post_synapses(at, weight);
+  }
+
+  method :stimulate, {:at => 'simtime'},{:weight => 'real'},{:source => NeuralEntity}, %{
+    stimuli_add(at, weight);
+  }
+
+end

data/lib/Yinspire/Models/Neuron_Input.rb

@@ -0,0 +1,12 @@
+require 'Yinspire/Models/Neuron_InputOutput'
+
+#
+# Input Neuron. Simply forwards stimuli.
+#
+class Neuron_Input < Neuron_InputOutput
+
+  method :fire, {:at => 'simtime'},{:weight => 'real'}, %{
+    stimulate_synapses(at, weight);
+  }
+
+end

data/lib/Yinspire/Models/Neuron_InputOutput.rb

@@ -0,0 +1,39 @@
+require 'Yinspire/Models/Neuron_Base'
+
+#
+# Common base class for input and output neurons. They behave almost
+# the same except for what action is performed once a neuron fires.
+#
+class Neuron_InputOutput < Neuron_Base
+
+  virtual :fire
+  method :fire, {:at => 'simtime'},{:weight => 'real'}, nil
+
+  # 
+  # Process each stimuli separately, i.e. it does NOT 
+  # add stimuli with the same timestamp together.
+  #
+  method :process, {:at => 'simtime'}, %{
+    simtime _at;
+    real _weight;
+
+    while (!@stimuli_pq.empty() && @stimuli_pq.top().at <= at)
+    {
+      _at = @stimuli_pq.top().at;
+      _weight = @stimuli_pq.top().weight;
+      @stimuli_pq.pop();
+      @simulator->record_fire(_at, _weight, this);
+      fire(_at, _weight);
+    }
+
+    /*
+     * 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);
+    }
+  }
+
+end

data/lib/Yinspire/Models/Neuron_Output.rb

@@ -0,0 +1,15 @@
+require 'Yinspire/Models/Neuron_InputOutput'
+
+#
+# Output Neuron. Used to record fire events.
+#
+class Neuron_Output < Neuron_InputOutput
+
+  stub_method :fire, {:at => 'simtime'},{:weight => 'real'}
+
+  #
+  # Overwrite
+  #
+  def fire(at, weight) end
+ 
+end

data/lib/Yinspire/Models/Neuron_SRM01.rb

@@ -0,0 +1,50 @@
+require 'Yinspire/Models/Neuron_Base'
+
+#
+# Formerly known as KernelbasedLIF
+#
+class Neuron_SRM01 < Neuron_Base
+
+  property :tau_m,           'real', :marshal => true
+  property :tau_ref,         'real', :marshal => true
+  property :ref_weight,      'real', :marshal => true
+  property :mem_pot,         'real', :marshal => true
+  property :const_threshold, 'real', :marshal => true
+
+  method :stimulate, {:at => 'simtime'},{:weight => 'real'},{:source => NeuralEntity}, %{
+    if (at >= @last_fire_time + @abs_refr_duration)
+    {
+      @simulator->event_counter++;
+      super::stimulate(at, weight, source);
+    }
+  }
+
+  method :process, {:at => 'simtime'}, %{
+    real weight = stimuli_sum(at);
+    const real delta = at - @last_fire_time - @abs_refr_duration;
+
+    if (delta < 0.0) return;
+
+    /*
+     * Calculate new membrane potential
+     */
+
+    @mem_pot = weight + @mem_pot * real_exp( -(at - @last_spike_time)/@tau_m );
+    @last_spike_time = at;
+
+    /*
+     * Calculate dynamic threshold
+     */
+    const real dynamic_threshold = @ref_weight * real_exp(-delta/@tau_ref);
+
+    if (@mem_pot >= @const_threshold + dynamic_threshold)
+    {
+      /* Fire */
+      @mem_pot = 0.0;
+      @last_fire_time = at;
+      @simulator->record_fire(at, Infinity, this);
+      stimulate_synapses(at, Infinity);
+    }
+  }
+
+end

data/lib/Yinspire/Models/Neuron_SRM02.rb

@@ -0,0 +1,64 @@
+require 'Yinspire/Models/Neuron_Base'
+
+#
+# Formerly known as SpecialEKernel
+#
+class Neuron_SRM02 < Neuron_Base
+
+  property :tau_m,           'real', :marshal => true
+  property :tau_ref,         'real', :marshal => true
+  property :reset,           'real', :marshal => true
+  property :u_reset,         'real', :marshal => true
+  property :mem_pot,         'real', :marshal => true
+  property :const_threshold, 'real', :marshal => true
+
+  method :stimulate, {:at => 'simtime'},{:weight => 'real'},{:source => NeuralEntity}, %{
+    @simulator->event_counter++;
+    super::stimulate(at, weight, source);
+  }
+
+  method :process, {:at => 'simtime'}, %{
+    real weight = stimuli_sum(at);
+
+    /*
+     * Calculate new membrane potential
+     */
+
+    @mem_pot = weight + @mem_pot * real_exp( -(at - @last_spike_time)/@tau_m );
+    @last_spike_time = at;
+
+    if (at < @last_fire_time + @abs_refr_duration)
+      return;
+
+    /*
+     * Calculate dynamic reset
+     */
+    const real delta = at - @last_fire_time - @abs_refr_duration;
+    const real dynamic_reset = @reset * real_exp(-delta/@tau_ref);
+
+    if (@mem_pot >= @const_threshold + dynamic_reset)
+    {
+      /* Fire */
+
+      if (@abs_refr_duration > 0.0)
+      {
+        schedule(at + @abs_refr_duration);
+      }
+
+      if (isinf(@mem_pot))
+      {
+        @mem_pot = 0.0;
+        @reset = @u_reset;
+      }
+      else
+      {
+        @reset = dynamic_reset + @u_reset;
+      }
+      @last_fire_time = at;
+
+      @simulator->record_fire(at, Infinity, this);
+      stimulate_synapses(at, Infinity);
+    }
+  }
+
+end

data/lib/Yinspire/Models/Synapse_Hebb.rb

@@ -0,0 +1,67 @@
+class Synapse_Hebb < Synapse
+
+  property :last_post_neuron_fire_time,    'simtime', :init => -Infinity, :marshal => true
+  property :current_post_neuron_fire_time, 'simtime', :init => -Infinity, :marshal => true
+  property :learning_rate,                 'real',    :init => 0.01,      :marshal => true
+  property :decrease_rate,                 'real',    :init => 0.00005,   :marshal => true
+  property :pre_synaptic_spikes,           'Array<simtime>'
+
+  #
+  # Default arguments for learning_window method
+  #
+  DEFAULT_LW_ARGS = "1, 1, 10, 8" 
+
+  method :stimulate, {:at => 'simtime'},{:weight => 'real'},{:source => NeuralEntity}, %{
+    if (source != @post_neuron)
+    {
+      @pre_synaptic_spikes.push(at);
+
+      if (@last_post_neuron_fire_time > 0.0)
+      {
+        real delta_time = @last_post_neuron_fire_time - at;  
+        real delta_weight = @learning_rate * learning_window(delta_time, #{DEFAULT_LW_ARGS});
+
+        if (@pre_synaptic_spikes.size() > 1)
+        {
+          delta_time = @pre_synaptic_spikes[@pre_synaptic_spikes.size() - 2] - at;
+        }
+
+        delta_weight += @decrease_rate * delta_time;
+        @weight += (1.0 - real_fabs(@weight)) * delta_weight;
+      }
+
+      @post_neuron->stimulate(at+@delay, @weight, this);
+    }
+    else
+    {
+      @last_post_neuron_fire_time = @current_post_neuron_fire_time; 
+      @current_post_neuron_fire_time = at;
+
+      real delta_weight = 0.0;
+
+      for (int i=0; i < @pre_synaptic_spikes.size(); i++)
+      {
+        delta_weight += @learning_rate * learning_window(at - @pre_synaptic_spikes[i], #{DEFAULT_LW_ARGS});
+      }
+
+      @weight += (1.0 - real_fabs(@weight)) * delta_weight;
+      @pre_synaptic_spikes.clear();
+    }
+  }
+
+  static_method :learning_window, 
+                {:delta_x => 'real'},
+                {:pos_ramp => 'real'},{:neg_ramp => 'real'},
+                {:pos_decay => 'real'},{:neg_decay => 'real'},
+                {:returns => 'real'}, %{
+    if (delta_x >= 0)
+    {
+      return (pos_ramp * delta_x * real_exp(-delta_x/pos_decay));
+    }
+    else
+    {
+      return (neg_ramp * delta_x * real_exp(delta_x/neg_decay));
+    }
+  }
+
+end

data/pure_cpp/Makefile

@@ -0,0 +1,22 @@
+CC=g++
+#PROFILE=-O0 -pg -g
+CFLAGS=-DNDEBUG -O3 -Winline -Wall -DWITHOUT_MMAP -I${PWD}/src
+
+DEPS=src/algo/binary_heap.h src/algo/indexed_binary_heap.h src/memory_allocator.h \
+     src/neuron.h src/neuron_srm_01.h src/simulator.h \
+     src/synapse.h src/types.h \
+     src/neural_entity.cc src/neuron.cc src/neuron_srm_01.cc \
+     src/simulator.cc src/synapse.cc \
+     src/main.cc \
+     src/json/json.h src/json/json_parser.h src/json/json.cc src/json/json_parser.cc \
+     Makefile
+
+inspire: ${DEPS}
+	${CC} ${CFLAGS} `find src -name '*.cc'` -o inspire ${LDFLAGS}
+
+src/json/json_parser.cc: src/json/json_parser.rl
+	ragel src/json/json_parser.rl | rlgen-cd -o src/json/json_parser.cc
+
+clean:
+	rm -f inspire
+

data/pure_cpp/README

@@ -0,0 +1,2 @@
+Compile with -DWITHOUT_MMAP on Windows or any other platform that does
+not support mmap(2).

data/pure_cpp/src/algo/binary_heap.h

@@ -0,0 +1,277 @@
+/*
+ * An implicit Binary Heap.
+ *
+ * Copyright (c) 2007, 2008 by Michael Neumann (mneumann@ntecs.de)
+ *
+ * NOTE: We start counting from 1 in the elements array!
+ *
+ * Template parameters:
+ *
+ *   E:        Element type
+ *   Alloc:    Allocator
+ *   Acc:      Accessor struct. Defines ordering relation (less).
+ *   MIN_CAPA: minimum number of elements
+ *
+ * Example:
+ *
+ *   struct Acc
+ *   {
+ *     static inline bool less(const int& a, const int& b)
+ *     {
+ *       return a < b;
+ *     }
+ *   };
+ *
+ *   BinaryHeap<int, MemoryAllocator, Acc> heap;
+ *   heap.push(4);
+ *   heap.pop();
+ *   ...
+ *
+ */
+
+#ifndef __YINSPIRE__BINARY_HEAP__
+#define __YINSPIRE__BINARY_HEAP__
+
+#include <assert.h>
+
+/*
+ * This is used to be able to keep track of
+ * an elements index in the IndexedBinaryHeap subclass.
+ * Unused in this class.
+ */
+template <typename E>
+struct BinaryHeapDummyIndexer
+{
+  static inline void index_changed(E& e, unsigned int i) 
+  {
+    /* DUMMY */
+  }
+};
+
+template <typename E, class Alloc, class Acc=E, class Idx=BinaryHeapDummyIndexer<E>, unsigned int MIN_CAPA=1024>
+class BinaryHeap
+{
+    typedef unsigned int I; // index type
+
+  public:
+
+      BinaryHeap()
+      {
+        this->capacity = 0;
+        this->size_ = 0;
+        this->elements = NULL; // we do lazy allocation!
+      }
+
+      ~BinaryHeap()
+      {
+        if (this->elements != NULL)
+        {
+          Alloc::free(this->elements+1);
+        }
+        this->elements = NULL;
+      }
+
+    inline E&
+      top() const
+      {
+        assert(this->size > 0);
+        return this->elements[1];  
+      }
+
+    void
+      pop()
+      {
+        remove(1);
+      }
+
+    inline void
+      remove(I i)
+      {
+        assert(i <= this->size_);
+
+        // 
+        // Element i is removed from the heap and as such becomes
+        // a "bubble" (free element). Move the bubble until
+        // the bubble becomes a leaf element. 
+        //
+        Idx::index_changed(this->elements[i], 0);  // detach from heap
+        I bubble = move_bubble_down(i);
+
+        //
+        // Now take the last element and insert it at the position of
+        // the bubble. In case the bubble is already the last element we
+        // are done.
+        //
+        if (bubble != this->size_)
+        {
+          insert_and_bubble_up(bubble, this->elements[this->size_]);
+        }
+        --this->size_;
+      }
+
+    void
+      push(const E& element)
+      {
+        if (this->size_ >= this->capacity) resize(2*this->capacity);
+        insert_and_bubble_up(++this->size_, element);
+      }
+
+    inline I
+      size() const
+      {
+        return this->size_;
+      }
+
+    inline bool
+      empty() const
+      {
+        return (this->size_ == 0);
+      }
+
+    /*
+     * A return value of +false+ means that the element wasn't accumulated with
+     * another element and as such has to be inserted into the heap.
+     */
+    bool
+      accumulate(const E& element, bool (*accum)(E&,const E&,void*), void *data)
+      {
+        I i;
+
+        //
+        // Find the position of the first element that is less than +element+.
+        // 
+        for (i = this->size_; i != 0 && Acc::less(element, this->elements[i]); i /= 2);
+
+        assert(i == 0 || Acc::less(this->elements[i], element)); 
+
+        if (i == 0 || !accum(this->elements[i], element, data))
+        {
+          return false;
+        }
+        return true;
+      }
+
+    /*
+     * Iterate over all elements (non-destructive)
+     */
+    void
+      each(void (*yield)(const E&, void*), void *data)
+      {
+        for (I i=1; i <= this->size_; i++)
+        {
+          yield(this->elements[i], data);
+        }
+      }
+ 
+  protected:
+
+    /*
+     * Insert +element+ into the heap beginning from
+     * +i+ and searching upwards to the root for the 
+     * right position (heap ordered) to insert.
+     *
+     * Element at index +i+ MUST be empty, i.e. unused!
+     */
+    inline void
+      insert_and_bubble_up(I i, const E& element)
+      {
+        for (;i >= 2 && Acc::less(element, this->elements[i/2]); i /= 2)
+        {
+          store_element(i, this->elements[i/2]);
+        }
+
+        // finally store it into the determined hole
+        store_element(i, element);
+      }
+
+    /*
+     * Move the bubble (empty element) at +i+ down in direction
+     * to the leaves. When the bubble reaches a leaf, stop and
+     * return the index of the leaf element which is now empty.
+     */
+    inline I 
+      move_bubble_down(I i)
+      {
+        const I sz = this->size_;
+        I right_child = i * 2 + 1;
+
+        while (right_child <= sz) 
+        {
+          if (Acc::less(this->elements[right_child-1], this->elements[right_child]))
+          {
+            --right_child; // minimum child is left child
+          }
+
+          store_element(i, this->elements[right_child]);
+          i = right_child;
+          right_child = i * 2 + 1;
+        }
+
+        //
+        // Edge case (comparison with the last element)
+        //
+        if (right_child-1 == sz)
+        {
+          store_element(i, this->elements[right_child-1]);
+          i = right_child-1;
+        }
+
+        return i;
+      }
+
+    /*
+     * The 0'th element is never used (accessed), so 
+     * we allocate only "capacity" elements (instead of capacity+1)
+     * and move the pointer one element before the begin of the 
+     * allocated memory. 
+     */
+    void
+      resize(I new_capacity)
+      {
+        E *new_elements;
+
+        if (new_capacity < MIN_CAPA) this->capacity = MIN_CAPA;  
+        else this->capacity = new_capacity;
+
+        //
+        // We do lazy allocation!
+        //
+        if (this->elements != NULL)
+        {
+          new_elements = Alloc::realloc_n(this->elements+1, this->capacity);
+        }
+        else
+        {
+          new_elements = Alloc::alloc_n(this->capacity);
+        }
+
+        assert(new_elements != NULL);
+        assert(this->capacity >= this->size);
+
+        //
+        // move pointer so that we "introduce" a zero'th 
+        // element.
+        //
+        this->elements = new_elements-1;
+      }
+
+    /*
+     * FIXME: cannot overwrite method in a subclass 
+     * The only purpose of this method is that we overwrite it in the
+     * subclass IndexedBinaryHeap to keep track of an elements index.
+     */
+    inline void
+      store_element(I i, const E& element)
+      {
+        this->elements[i] = element;
+        Idx::index_changed(this->elements[i], i); 
+      }
+
+  protected:
+
+    I  size_;
+    E *elements;
+    I  capacity;
+};
+
+#endif