yinspire 0.1.0

data/pure_cpp/src/neural_entity.h

@@ -0,0 +1,243 @@
+#ifndef __YINSPIRE__NEURAL_ENTITY__
+#define __YINSPIRE__NEURAL_ENTITY__
+
+#include "types.h"
+#include "memory_allocator.h"
+#include "algo/binary_heap.h"
+#include "json/json.h"
+
+class Simulator; // forward declaration
+
+/*
+ * The data structure used for storing a fire impluse or any other form
+ * of stimulation.
+ */
+struct Stimulus
+{
+  simtime at;
+  real weight;
+
+  inline static bool
+    less(const Stimulus &a, const Stimulus &b)
+    {
+      return (a.at < b.at); 
+    }
+};
+
+/*
+ * The NeuralEntity is the base class of all entities in a neural net,
+ * i.e. Neurons and Synapses. 
+ */
+class NeuralEntity
+{
+  protected: 
+
+    /*
+     * Each NeuralEntity has a pointer to the Simulator.
+     * This is used for example to update it's scheduling
+     * or to report a fire event.
+     *
+     * It's assigned by the Simulator!
+     */
+    Simulator *simulator;
+
+    /*
+     * Each NeuralEntity has an +id+ associated which uniquely
+     * identifies itself within a Simulator instance. This +id+ is
+     * assigned by the Simulator and should not be changed by the
+     * NeuralEntity itself.
+     *
+     * The reference is NOT owned by the NeuralEntity. It's the
+     * responsibility of the Simulator to allocate and free the memory! 
+     */
+    const char *id;
+
+    /*
+     * 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 for a specific time.
+     */
+    uint schedule_index;
+
+    /*
+     * The timestamp of the earliest event in the local priority queue.
+     */
+    simtime schedule_at;
+
+    /*
+     * If stepped scheduling is used, points to the previous/next
+     * entity in the schedule list.
+     */
+    NeuralEntity *schedule_stepping_list_prev;
+    NeuralEntity *schedule_stepping_list_next;
+
+    /*
+     * 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!
+     */
+    NeuralEntity *schedule_stepping_list_internal_next;
+
+    /*
+     * Each NeuralEntity has it's own local stimuli priority queue.
+     * Neurons make use of this whereas Synapses currently not. 
+     *
+     * It's a quite low overhead to have this in the NeuralEntity class,
+     * just around 12 additional bytes.
+     */
+    BinaryHeap<Stimulus, MemoryAllocator<Stimulus> > stimuli_pq;
+
+  public:
+
+    /*
+     * Constructor
+     */
+    NeuralEntity();
+
+    /*
+     * Destructor
+     */
+    virtual ~NeuralEntity();
+
+    /*
+     * Load the internal state of a NeuralEntity
+     * from +data+.
+     *
+     * Note that loading does not neccessarily reset
+     * the internal state of the entity!
+     */
+    virtual void load(jsonHash *data); 
+
+    /*
+     * Dump the internal state of a NeuralEntity
+     * and return it. Internal state does not contain 
+     * the network connection (they have to be dumped
+     * separatly by the simulator using +each_connection+.
+     */ 
+    virtual void dump(jsonHash *into);
+
+    /*
+     * Connect +self+ with +target+.
+     */
+    virtual void connect(NeuralEntity *target) = 0;
+
+    /*
+     * Disconnect +self+ from +target+.
+     */
+    virtual void disconnect(NeuralEntity *target) = 0;
+
+    /*
+     * Disconnect from all connections. Uses +each_connection+ and
+     * +disconnect+.
+     */
+    void disconnect_all();
+
+    /*
+     * Calls the iterator function for each outgoing connection.
+     */
+    virtual void each_connection(
+        void (*yield)(NeuralEntity *self, NeuralEntity *conn)) = 0;
+
+    /*
+     * Stimulate an entity at a specific time with a specific weight.
+     */
+    virtual void stimulate(simtime at, real weight, NeuralEntity *source) = 0;
+
+    /*
+     * This method is called when a NeuralEntity reached it's scheduling
+     * time.
+     *
+     * Overwrite it if you need this behaviour.
+     */
+    virtual void
+      process(simtime at)
+      {
+        throw "Abstract method";
+      } 
+
+    /*
+     * This method is called in each time-step, if a NeuralEntity
+     * uses stepped scheduling. 
+     *
+     * Overwrite it if you need this behaviour.
+     */
+    virtual void
+      process_stepped(simtime at, simtime step)
+      { 
+        throw "Abstract method";
+      }
+
+    /*
+     * Attribute accessor functions
+     */
+    void        set_simulator(Simulator *simulator);
+    void        set_id(const char *id);
+    Simulator  *get_simulator() const;
+    const char *get_id() const;
+    inline simtime get_schedule_at() const { return this->schedule_at; }
+
+  protected:
+
+    /*
+     * Schedules the entity at a specific time.
+     */
+    void schedule(simtime at);
+
+    /*
+     * Returns true if stepped scheduling is enabled.
+     */
+    bool schedule_stepping_enabled();
+
+    /* 
+     * Enable/Disable stepped scheduling. 
+     */
+    void schedule_enable_stepping();
+    void schedule_disable_stepping();
+
+    /*
+     * Add a Stimuli to the local pq.
+     */
+    void stimuli_add(simtime at, real weight);
+
+    /*
+     * Sum all Stimuli until +until+.
+     */
+    real stimuli_sum(simtime until);
+
+    /*
+     * Sum all Stimuli until +until+, but treat infinite values
+     * differently.  Do not sum them, instead set +is_inf+ to true.
+     */
+    real stimuli_sum_inf(simtime until, bool &is_inf);
+
+  public:
+
+    /*
+     * Accessor function for BinaryHeap
+     */
+    inline static bool
+      less(const NeuralEntity *a, const NeuralEntity *b) 
+      {
+        return (a->schedule_at < b->schedule_at);
+      }
+
+    /*
+     * Accessor function for BinaryHeap
+     */
+    inline static uint &
+      index(NeuralEntity *self)
+      {
+        return self->schedule_index;
+      }
+
+};
+
+#endif

data/pure_cpp/src/neuron.cc

@@ -0,0 +1,136 @@
+#include "neuron.h"
+#include "synapse.h"
+#include <math.h>
+#include <assert.h>
+#include "simulator.h" // ?
+
+Neuron::Neuron()
+{
+  this->first_pre_synapse = NULL;
+  this->first_post_synapse = NULL;
+  this->abs_refr_duration = 0.0;
+  this->last_spike_time = -INFINITY; 
+  this->last_fire_time = -INFINITY; 
+  this->hebb = false;
+}
+
+void
+Neuron::dump(jsonHash *into)
+{
+}
+
+void
+Neuron::load(jsonHash *data)
+{
+  super::load(data);
+
+  this->abs_refr_duration = data->get_number("abs_refr_duration", 0.0);
+  this->last_spike_time = data->get_number("last_spike_time", -INFINITY);
+  this->last_fire_time = data->get_number("last_fire_time", -INFINITY);
+  this->hebb = data->get_bool("hebb", false);
+}
+ 
+void
+Neuron::each_connection(void (*yield)(NeuralEntity *self, NeuralEntity *conn))
+{
+  for (Synapse *syn = this->first_post_synapse; syn != NULL;
+      syn = syn->next_post_synapse)
+  {
+    yield(this, syn);
+  }
+}
+
+void
+Neuron::stimulate(simtime at, real weight, NeuralEntity *source)
+{
+  stimuli_add(at, weight);
+}
+
+/*
+ * Adding a post synapse. Target must be a Synapse.
+ *
+ * O(1)
+ */
+void
+Neuron::connect(NeuralEntity *target)
+{
+  Synapse *syn = dynamic_cast<Synapse*>(target);
+
+  if (syn->pre_neuron != NULL || syn->next_post_synapse != NULL)
+    throw "Synapse already connected";
+
+  syn->next_post_synapse = this->first_post_synapse;
+  this->first_post_synapse = syn;
+  syn->pre_neuron = this;
+}
+
+/*
+ * O(n)
+ */
+void
+Neuron::disconnect(NeuralEntity *target)
+{
+  Synapse *syn = dynamic_cast<Synapse*>(target);
+
+  if (syn->pre_neuron != this)
+    throw "Synapse not connected to this Neuron";
+
+  /*
+   * Find the synapse in the linked list that precedes +syn+.
+   */
+  Synapse *prev = NULL;
+  Synapse *curr = this->first_post_synapse;
+
+  while (true)
+  {
+    if (curr == NULL) break;
+    if (curr == syn) break; 
+    prev = curr;
+    curr = curr->next_post_synapse;
+  }
+
+  if (curr != syn)
+    throw "Synapse not in post synapse list";
+
+  /*
+   * Remove syn from linked list
+   */
+  if (prev == NULL)
+  {
+    /*
+     * syn is the last synapse in the post synapse list.
+     */
+    assert(this->first_post_synapse == syn);
+    this->first_post_synapse = NULL; 
+  }
+  else
+  {
+    prev->next_post_synapse = syn->next_post_synapse;
+  }
+
+  syn->pre_neuron = NULL;
+  syn->next_post_synapse = NULL;
+}
+
+/*
+ * NOTE: The stimulation weight is 0.0 below
+ * as the synapse will add it's weight to the
+ * preceding neurons.
+ */
+void
+Neuron::fire_synapses(simtime at)
+{
+  if (this->hebb) 
+  {
+    for (Synapse *syn = this->first_pre_synapse; syn != NULL;
+        syn = syn->next_pre_synapse)
+    {
+      syn->stimulate(at, 0.0, this);
+    }
+  }
+  for (Synapse *syn = this->first_post_synapse; syn != NULL;
+      syn = syn->next_post_synapse)
+  {
+    syn->stimulate(at, 0.0, this);
+  }
+}

data/pure_cpp/src/neuron.h

@@ -0,0 +1,70 @@
+#ifndef __YINSPIRE__NEURON__
+#define __YINSPIRE__NEURON__
+
+#include "neural_entity.h"
+
+class Synapse; // forward declaration
+
+/*
+ * The base class of all neurons.
+ */
+class Neuron : public NeuralEntity
+{
+    friend class Synapse;
+    typedef NeuralEntity super; 
+
+  protected:
+
+    /*
+     * Pointers to the first pre/post synapse
+     */
+    Synapse *first_pre_synapse;
+    Synapse *first_post_synapse;
+
+    /*
+     * Duration of the absolute refraction period.
+     */
+    simtime abs_refr_duration; 
+
+    /*
+     * Last spike time
+     */
+    simtime last_spike_time;
+
+    /*
+     * Last fire time
+     */
+    simtime last_fire_time;
+
+    /*
+     * Whether this neuron is a hebb neuron or not.
+     * A hebb neuron also stimulates it's pre synapses
+     * upon firing.
+     */
+    bool hebb;
+
+  protected:
+
+    /*
+     * Constructor
+     */
+    Neuron();
+
+  public:
+
+    virtual void dump(jsonHash *into);
+    virtual void load(jsonHash *data);
+
+    virtual void stimulate(simtime at, real weight, NeuralEntity *source);
+    virtual void connect(NeuralEntity *target);
+    virtual void disconnect(NeuralEntity *target);
+    virtual void each_connection(
+      void (*yield)(NeuralEntity *self, NeuralEntity *conn));
+
+  protected:
+
+    void fire_synapses(simtime at);
+
+};
+
+#endif