yinspire 0.1.0

data/pure_cpp/src/neuron_srm_01.cc

@@ -0,0 +1,77 @@
+#include "neuron_srm_01.h"
+#include "simulator.h"
+#include <math.h>
+
+// formerly known as KernelbasedLIF
+
+
+Neuron_SRM_01::Neuron_SRM_01()
+{
+  this->tau_m = 0.0;
+  this->tau_ref = 0.0;
+  this->ref_weight = 0.0;
+  this->mem_pot = 0.0;
+  this->const_threshold = 0.0;
+}
+
+void
+Neuron_SRM_01::dump(jsonHash *into)
+{
+}
+
+void
+Neuron_SRM_01::load(jsonHash *data)
+{
+  super::load(data);
+
+  this->tau_m = data->get_number("tau_m", 0.0);
+  this->tau_ref = data->get_number("tau_ref", 0.0);
+  this->ref_weight = data->get_number("ref_weight", 0.0);
+  this->mem_pot = data->get_number("mem_pot", 0.0);
+  this->const_threshold = data->get_number("const_threshold", 0.0);
+}
+
+void
+Neuron_SRM_01::stimulate(simtime at, real weight, NeuralEntity *source)
+{
+  if (at >= this->last_fire_time + this->abs_refr_duration)
+  {
+    ++this->simulator->stat_event_counter;
+    super::stimulate(at, weight, source);
+  }
+}
+
+void
+Neuron_SRM_01::process(simtime at)
+{
+  real weight = stimuli_sum(at);
+  const real delta = at - this->last_fire_time - this->abs_refr_duration;
+
+  if (delta < 0.0) return;
+
+  /*
+   * Calculate new membrane potential
+   */
+
+  this->mem_pot = weight + this->mem_pot * real_exp( -(at - this->last_spike_time)/this->tau_m );
+  this->last_spike_time = at;
+
+  /*
+   * Calculate dynamic threshold
+   */
+  const real dynamic_threshold = this->ref_weight * real_exp(-delta/this->tau_ref);
+
+  if (this->mem_pot >= this->const_threshold + dynamic_threshold)
+  {
+    fire(at);
+  }
+}
+
+void
+Neuron_SRM_01::fire(simtime at)
+{
+  this->simulator->stat_record_fire_event(at, this);
+  this->mem_pot = 0.0;
+  this->last_fire_time = at;
+  fire_synapses(at);
+}

data/pure_cpp/src/neuron_srm_01.h

@@ -0,0 +1,36 @@
+#ifndef __YINSPIRE__NEURON_SRM_01__
+#define __YINSPIRE__NEURON_SRM_01__
+
+#include "neuron.h"
+
+class Neuron_SRM_01 : public Neuron 
+{
+    typedef Neuron super; 
+
+  protected:
+
+    real tau_m;
+    real tau_ref;
+    real ref_weight;
+    real mem_pot;
+    real const_threshold;
+
+  public:
+
+    Neuron_SRM_01();
+
+  public:
+
+    virtual void dump(jsonHash *into);
+    virtual void load(jsonHash *data);
+
+    virtual void stimulate(simtime at, real weight, NeuralEntity *source);
+    virtual void process(simtime at);
+
+  protected:
+
+    void fire(simtime at);
+
+};
+
+#endif

data/pure_cpp/src/simulator.cc

@@ -0,0 +1,151 @@
+#include <math.h>
+#include <string>
+#include "simulator.h"
+#include "json/json_parser.h"
+
+Simulator::Simulator()
+{
+  this->schedule_current_time = 0.0;
+  this->schedule_step = INFINITY;
+  this->schedule_next_step = this->schedule_current_time + this->schedule_step;
+  this->schedule_stepping_list_root = NULL;
+  this->stimuli_tolerance = 0.0;
+  this->stat_event_counter = 0;
+  this->stat_fire_counter = 0;
+}
+
+void
+Simulator::entity_register_type(const char *type, entity_factory_t factory)
+{
+  this->types[type] = factory;
+}
+
+NeuralEntity*
+Simulator::entity_allocate(const char* type)
+{
+  entity_factory_t factory = this->types[type];
+  return factory();
+}
+
+void
+Simulator::load(const char *filename)
+{
+  jsonHash *data = jsonParser::parse_file_mmap(filename)->asHash();
+
+  std::string format = data->get("format")->asString()->value;
+
+  if (format != "yinspire.c")
+  {
+    throw "unrecognized data format";
+  }
+
+  jsonHash *templates = data->get("templates")->asHash();
+  jsonArray *entities = data->get("entities")->asArray();
+  jsonArray *connections = data->get("connections")->asArray();
+  jsonHash *events = data->get("events")->asHash();
+
+  /*
+   * construct entities
+   */
+  jsonArrayIterator_EACH(entities, e)
+  {
+    jsonArray *entity_spec = e->asArray();
+    jsonString *id = entity_spec->get(0)->asString();
+    jsonString *template_name = entity_spec->get(1)->asString();
+
+    jsonArray *t = templates->get(template_name)->asArray();
+
+    jsonString *type = t->get(0)->asString();
+    jsonHash *hash = t->get(1)->asHash();
+
+    NeuralEntity *entity = entity_allocate(type->value.c_str());
+
+    entity->set_id(strdup(id->asString()->value.c_str()));
+    entity->set_simulator(this);
+    this->entities[entity->get_id()] = entity;
+
+    entity->load(hash);
+  }
+
+  /*
+   * connect entities
+   */
+  jsonArrayIterator_EACH(connections, conn)
+  {
+    NeuralEntity *from = NULL;
+    jsonArrayIterator_EACH(conn->asArray(), i)
+    {
+      std::string &id = i->asString()->value;
+      NeuralEntity *e = this->entities[id.c_str()]; 
+      if (from == NULL) from = e;
+      else from->connect(e);
+    } 
+  }
+
+  /*
+   * events
+   */
+  jsonHashIterator_EACH(events, key, val) 
+  {
+    NeuralEntity *entity = this->entities[key->value.c_str()];
+    jsonArrayIterator_EACH(val->asArray(), e)
+    {
+      entity->stimulate(e->asNumber()->value, INFINITY, NULL);  
+    }
+  }
+
+  data->ref_decr();
+}
+
+void
+Simulator::run(simtime stop_at)
+{
+  while (true)
+  {
+    simtime next_stop = MIN(stop_at, this->schedule_next_step);
+
+    /* 
+     * Calculate all events from the priority queue until the next time
+     * step is reached.
+     */
+    while (!this->schedule_pq.empty())
+    {
+      NeuralEntity *top = this->schedule_pq.top();
+      if (top->get_schedule_at() >= next_stop)
+        break;
+      this->schedule_current_time = top->get_schedule_at(); 
+      this->schedule_pq.pop();
+      top->process(top->get_schedule_at());
+    }
+
+    if (this->schedule_current_time >= stop_at)
+      break;
+
+    if (this->schedule_stepping_list_root == NULL && this->schedule_pq.empty())
+      break;
+
+    /* 
+     * Calculate the entities that require stepped processing.
+     */ 
+    this->schedule_current_time = this->schedule_next_step; 
+
+    if (this->schedule_stepping_list_root != NULL)
+    {
+      // FIXME: collect all entities in an array. then process them.
+    }
+
+    this->schedule_next_step += this->schedule_step;
+  }
+}
+
+void
+Simulator::schedule_update(NeuralEntity *entity)
+{
+  this->schedule_pq.update(entity);
+}
+
+void
+Simulator::stat_record_fire_event(simtime at, NeuralEntity *source)
+{
+  ++this->stat_fire_counter;
+}

data/pure_cpp/src/simulator.h

@@ -0,0 +1,116 @@
+#ifndef __YINSPIRE__SIMULATOR__
+#define __YINSPIRE__SIMULATOR__
+
+#include "types.h"
+#include "neural_entity.h" 
+#include "memory_allocator.h"
+#include "algo/indexed_binary_heap.h"
+#include <string.h>
+#include <map>
+
+struct ltstr
+{
+  inline bool operator()(const char *s1, const char *s2) const
+  {
+    return strcmp(s1, s2) < 0;
+  }
+};
+
+class Simulator
+{
+    friend class NeuralEntity;
+
+  protected:
+
+    /*
+     * The current time.
+     */
+    simtime schedule_current_time;
+
+    /*
+     * The time step used for stepped scheduling.
+     */
+    simtime schedule_step;
+
+    /*
+     * The time of the next step.
+     */
+    simtime schedule_next_step;
+
+    /*
+     * The tolerance (time difference) up to which local stimuli are
+     * accumulated.
+     */
+    simtime stimuli_tolerance;
+
+    /*
+     * Priority queue used to schedule the entities.
+     */
+    IndexedBinaryHeap<NeuralEntity *, MemoryAllocator<NeuralEntity*>, NeuralEntity> schedule_pq;
+
+    /*
+     * If stepped scheduling is used, this points to the 
+     * first entity in the stepped schedule list.   
+     */
+    NeuralEntity *schedule_stepping_list_root;
+
+    /*
+     * An id -> NeuralEntity mapping
+     *
+     * Contains all entities known by the simulator.
+     */
+    std::map<const char *, NeuralEntity *, ltstr> entities;
+
+    /*
+     * An entity type name -> "factory function for this type" mapping.
+     */
+    typedef NeuralEntity* (*entity_factory_t)();
+    std::map<const char *, entity_factory_t, ltstr> types;
+
+  public:
+
+    /*
+     * Constructor
+     */
+    Simulator();
+
+    /*
+     * Load the neural net from +filename+.
+     */
+    void load(const char *filename);
+
+    /*
+     * Start the simulation.
+     */
+    void run(simtime stop_at);
+
+    /*
+     * Register an entity type and the corresponding +factory+ function.
+     */
+    void entity_register_type(const char *type, entity_factory_t factory);
+
+    /*
+     * Allocate an entity of the specified +type+.
+     */
+    NeuralEntity *entity_allocate(const char *type);
+
+    /*
+     * If an entity has changed it's scheduling time,
+     * it has to call this method to reflect the change within the
+     * priority queue.
+     */
+    void schedule_update(NeuralEntity *entity);
+
+    /*
+     * Notify that a fire event has happened
+     */
+    void stat_record_fire_event(simtime at, NeuralEntity *source);
+
+  public:
+
+    uint stat_fire_counter;
+    uint stat_event_counter;
+
+};
+
+#endif

data/pure_cpp/src/synapse.cc

@@ -0,0 +1,117 @@
+#include "synapse.h"
+#include "neuron.h"
+#include <assert.h>
+
+Synapse::Synapse()
+{
+  this->weight = 0.0;
+  this->delay = 0.0;
+  this->pre_neuron = NULL;
+  this->post_neuron = NULL;
+  this->next_pre_synapse = NULL;
+  this->next_post_synapse = NULL;
+}
+
+void
+Synapse::dump(jsonHash *into)
+{
+}
+
+void
+Synapse::load(jsonHash *data)
+{
+  super::load(data);
+
+  this->weight = data->get_number("weight", 0.0);
+  this->delay = data->get_number("delay", 0.0);
+}
+
+
+void
+Synapse::stimulate(simtime at, real weight, NeuralEntity *source) 
+{
+  /* 
+   * 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).
+   *
+   * We ignore the weight parameter that is passed by the Neuron.
+   */ 
+  if (source != this->post_neuron)
+  {
+    this->post_neuron->stimulate(at + this->delay, this->weight, this);
+  }
+}
+
+
+/*
+ * Adding a pre synapse. Target must be a Neuron.
+ *
+ * O(1)
+ */
+void
+Synapse::connect(NeuralEntity *target)
+{
+  Neuron *neuron = dynamic_cast<Neuron*>(target);
+
+  if (this->post_neuron != NULL || this->next_pre_synapse != NULL)
+    throw "Synapse already connected";
+
+  this->next_pre_synapse = neuron->first_pre_synapse;
+  neuron->first_pre_synapse = this;
+  this->post_neuron = neuron;
+}
+
+/*
+ * O(n)
+ */
+void
+Synapse::disconnect(NeuralEntity *target)
+{
+  Neuron *neuron = dynamic_cast<Neuron*>(target);
+
+  if (this->post_neuron != neuron)
+    throw "Synapse not connected to this Neuron";
+
+  /*
+   * Find the synapse in the linked list that precedes +this+.
+   */
+  Synapse *prev = NULL;
+  Synapse *curr = neuron->first_pre_synapse;
+
+  while (true)
+  {
+    if (curr == NULL) break;
+    if (curr == this) break; 
+    prev = curr;
+    curr = curr->next_pre_synapse;
+  }
+
+  if (curr != this)
+    throw "Synapse not in pre synapse list";
+
+  /*
+   * Remove ourself (this) from linked list
+   */
+  if (prev == NULL)
+  {
+    /*
+     * we are the last synapse in the pre synapse list.
+     */
+    assert(neuron->first_pre_synapse == this);
+    neuron->first_pre_synapse = NULL; 
+  }
+  else
+  {
+    prev->next_pre_synapse = this->next_pre_synapse;
+  }
+
+  this->post_neuron = NULL;
+  this->next_pre_synapse = NULL;
+}
+
+void
+Synapse::each_connection(void (*yield)(NeuralEntity *self, NeuralEntity *conn))
+{
+  yield(this, this->post_neuron);
+}