yinspire 0.1.0

data/lib/Yinspire/Loaders/Loader_JSON.rb

@@ -0,0 +1,181 @@
+require 'Yinspire/Loaders/Loader'
+require 'yaml' # YAML is a superset of JSON
+
+class Loader_JSON < Loader
+
+  def load(filename)
+    @entities = Hash.new
+    data = YAML.load(File.read(filename))
+
+    case data['format']
+    when 'yinspire.1'
+      load_v1(data)
+    when 'yinspire.c'
+      load_c(data)
+    else
+      raise "invalid format"
+    end
+  end
+
+  protected
+
+  #
+  # Format:
+  #
+  #   {
+  #     templates: { 
+  #       'MyNeuron' =>  ['Neuron_SRM01', {tau_m: 0.5, :ref_weight: 0.1}],
+  #       'MySynapse' => ['Synapse', {weight: 1.0, delay: 0.5}]
+  #     },
+  #     entities: {
+  #       'id1' => ['MyNeuron', {tau_m: 5.1, const_threshold: 0.44}],
+  #       'id2' => ['Neuron_SRM01', {}],
+  #       'id3' => ['MySynapse'],
+  #       'id4' => 'MyNeuron'
+  #     },
+  #     connections: { 
+  #       'id1' => ['id2', 'id3'],
+  #       'id2' => ['id1']
+  #     },
+  #     events: {
+  #       'id1' => [100.0, 101.0, timestamp_x, timestamp_y],
+  #       'id2' => [444, 555]
+  #     }
+  #   }
+  #
+  # Every "section" is optional.
+  #
+  def load_v1(data)
+    templates = data['templates'] || {}
+    entities = data['entities'] || {}
+    connections = data['connections'] || {}
+    events = data['events'] || {}
+
+    #
+    # construct entities
+    #
+    hash = Hash.new
+    entities.each do |id, entity_spec|
+      type, data = *entity_spec
+
+      if t = templates[type]
+        type, template_data = *t
+        hash.update(template_data) if template_data
+      end
+
+      hash.update(data) if data
+
+      create_entity(type, id, hash)
+
+      hash.clear
+    end
+
+    #
+    # connect them
+    #
+    connections.each do |src, destinations|
+      entity = @entities[src]
+      destinations.each do |dest|
+        entity.connect(@entities[dest])
+      end
+    end
+
+    #
+    # stimulate with events
+    #
+    events.each do |id, time_series|
+      entity = @entities[id]
+      time_series.each do |at|
+        entity.stimulate(at, Infinity, nil)
+      end
+    end
+  end
+
+  #
+  # This is a version for the pure C++ version of Yinspire. It doesn't
+  # use hashes for entities and connections (because the C++ JSON library
+  # does not implement efficient hash lookup).
+  #
+  #   {
+  #     templates: { 
+  #       'MyNeuron' =>  ['Neuron_SRM01', {tau_m: 0.5, :ref_weight: 0.1}],
+  #       'MySynapse' => ['Synapse', {weight: 1.0, delay: 0.5}]
+  #     },
+  #     entities: [
+  #       ['id1', 'MyNeuron'],
+  #       ['id2', 'Neuron_SRM01'],
+  #       ['id3', 'MySynapse'],
+  #       ['id4', 'MyNeuron']
+  #     ],
+  #     connections: { 
+  #       ['id1', 'id2', 'id3'],
+  #       ['id2', 'id1']
+  #     },
+  #     events: {
+  #       'id1' => [100.0, 101.0, timestamp_x, timestamp_y],
+  #       'id2' => [444, 555]
+  #     }
+  #   }
+  #
+  # Every "section" is optional.
+  #
+  # BUGS:
+  #
+  # The C++ version does not currently implement to specify an
+  # entity like this:
+  #
+  #   ['id1', 'Neuron_SRM01', {...}]
+  #
+  def load_c(data)
+    templates = data['templates'] || {}
+    entities = data['entities'] || [] 
+    connections = data['connections'] || []
+    events = data['events'] || {}
+
+    #
+    # construct entities
+    #
+    hash = Hash.new
+    entities.each do |arr|
+      hash.clear
+
+      id, type, data = *arr
+
+      if t = templates[type]
+        type, template_data = *t
+        hash.update(template_data)
+      end
+
+      if data
+        hash.update(data) 
+        raise # FIXME: C++ version is invalid, because it assume that there 
+              # is no data! 
+      end
+
+      create_entity(type, id, hash)
+    end
+
+    #
+    # connect them
+    #
+    connections.each do |arr|
+      src, *destinations = *arr
+      raise if destinations.empty?
+      entity = @entities[src] || raise
+      destinations.each do |dest|
+        entity.connect(@entities[dest] || raise)
+      end
+    end
+
+    #
+    # stimulate with events
+    #
+    events.each do |id, time_series|
+      entity = @entities[id] || raise
+      time_series.each do |at|
+        entity.stimulate(at, Infinity, nil)
+      end
+    end
+  end
+
+end

data/lib/Yinspire/Loaders/Loader_Spike.rb

@@ -0,0 +1,42 @@
+require 'Yinspire/Loaders/Loader'
+
+#
+# Loader for spikes in the format:
+#
+#   Id1 weight1@time1 time2 time3 ...
+#   Id2 time1 time2 time3 ...
+#   ...
+#
+# Weight values (e.g. 1.0@time1) are optional. 
+#
+# Lines beginning with "#" are comments.
+#
+class Loader_Spike < Loader
+
+  def load(filename)
+    File.open(filename, 'r') do |f|
+      while line = f.gets
+        line.strip!
+        next if line =~ /^#/ # comment
+
+        #
+        # The following code is to help Matlab to generate spike trains
+        # more easily and allows spaces before and after the "@", e.g.
+        # "123 @ 444".
+        #
+        line.gsub!(/\s+@\s+/, '')
+
+        id, *spikes = line.split
+        raise if spikes.empty?
+        entity = @entities[id] || raise
+
+        spikes.each do |spike|
+          weight, at = spike.split("@") 
+          weight, at = Infinity, weight if at.nil? # spike is a pure time-value
+          entity.stimulate(at.to_f, weight.to_f, nil)
+        end
+      end
+    end
+  end
+
+end

data/lib/Yinspire/Loaders/Loader_Yin.rb

@@ -0,0 +1,62 @@
+require 'Yinspire/Loaders/Loader'
+require 'Yinspire/Loaders/YinScanner'
+
+#
+# This is a human readable data format for describing neural nets
+# as well as stimulations.
+#
+# Note that it is a streaming scanner/parser, i.e. it's important
+# to put the template definitions before you actually use them.
+# The same applies to stimulations and connections!
+#
+class Loader_Yin < Loader
+  require 'enumerator'
+
+  def load(filename)
+    templates = {}
+    hash = Hash.new
+    YinScanner.new(File.read(filename)).scan do |cmd|
+      case cmd.shift
+      when :entity
+        ids, type, prop_list = *cmd
+
+        hash.clear
+        if t = templates[type]
+          type, template_data = *t
+          hash.update(template_data) if template_data
+        end
+        hash.update(prop_list) if prop_list
+
+        ids.each {|id| create_entity(type, id, hash) }
+      when :connect
+        cmd.first.each_cons(2) do |from, to|
+          from.each {|f|
+            entity = @entities[f] 
+            to.each {|t| entity.connect(@entities[t]) }
+          }
+        end
+      when :stimulate
+        ids, stimuls = *cmd
+
+        ids.map! {|id| @entities[id] }
+
+        stimuls.each do |sti|
+          at, weight = *sti
+          weight ||= Infinity 
+          ids.each {|entity|
+            entity.stimulate(at, weight, nil)
+          }
+        end
+      when :template
+        ids, base_type, prop_list = *cmd
+        ids.each do |id|
+          raise if templates[id]
+          templates[id] = [base_type, prop_list] 
+        end
+      else
+        raise
+      end
+    end
+  end
+
+end

data/lib/Yinspire/Loaders/YinScanner.rb

@@ -0,0 +1,247 @@
+class YinScanner
+  require 'strscan'
+
+  def initialize(str)
+    @s = StringScanner.new(str)
+    @inf = 1.0/0.0
+  end
+
+  def scan
+    while cmd = scan_command()
+      yield cmd
+    end
+    skip_ws()
+    raise "ParseError" unless @s.eos?
+  end
+
+  protected
+
+  def skip_ws
+    while @s.skip(/(\s+)/) or # skip whitespace
+          @s.skip(/[#](.*)/) # skip comments
+    end
+  end
+
+  def scan_property
+    pos = @s.pos
+    if name = scan_id()
+      skip_ws()
+      if @s.skip(/=/)
+        value = scan_value()
+        if value != nil
+          return name, value
+        end
+      end
+    end
+
+    @s.pos = pos
+    return nil
+  end
+
+  def scan_command
+    skip_ws()
+    type = nil
+    if str = @s.scan(/(TEMPLATE|ENTITY|CONNECT|STIMULATE)\s+/)
+      str.strip!
+      str.downcase!
+      type = str.to_sym
+    end
+
+    ids = scan_idlist()
+    raise "ParseError" if type != nil and ids.empty?
+    return nil if ids.empty?
+
+    scanned_type = scan_type()
+
+    raise "ParseError" if (type and type != scanned_type) or scanned_type.nil?
+
+    case scanned_type
+    when :entity, :template
+      id = scan_id()
+      raise "ParseError" unless id
+      prop_list = scan_propertylist()
+      return scanned_type, ids, id, prop_list  
+    when :stimulate
+      stimuls = scan_stimulationlist()
+      raise "ParseError" unless stimuls
+      return scanned_type, ids, stimuls
+    when :connect
+      conns = [] 
+      conns << ids
+      loop do
+        l = scan_idlist()
+        break if l.empty?
+        conns << l
+
+        skip_ws()
+        break unless @s.skip(/->/)
+      end
+      raise "ParseError" if conns.size < 2
+      return scanned_type, conns
+    else
+      nil
+    end
+  end
+
+  def scan_propertylist
+    pos = @s.pos
+    skip_ws()
+    props = {}
+    if @s.skip(/[{]/)
+      loop do
+        name, value = scan_property() 
+        break unless name
+        props[name] = value
+      end
+      skip_ws()
+      return props if @s.skip(/[}]/)
+    end
+
+    @s.pos = pos
+    return nil
+  end
+
+  def scan_value
+    skip_ws()
+    if str = @s.scan(/[+-]?[0-9]+([.][0-9]+([eE][+-]?[0-9]+)?)?/)
+      str.to_f
+    elsif @s.skip(/[+]?Inf(inity)?/i)
+      @inf
+    elsif @s.skip(/[-]?Inf(inity)?/i)
+      -@inf
+    elsif @s.skip(/true/)
+      true
+    elsif @s.skip(/false/)
+      false
+    else
+      nil
+    end
+  end
+
+  # no skip_ws!
+  def scan_float
+    if str = @s.scan(/[+-]?[0-9]+([.][0-9]+([eE][+-]?[0-9]+)?)?/)
+      str.to_f
+    elsif @s.skip(/[+]?Inf(inity)?/i)
+      @inf
+    elsif @s.skip(/[-]?Inf(inity)?/i)
+      -@inf
+    else
+      nil
+    end
+  end
+
+  def scan_stimulationlist
+    pos = @s.pos
+    skip_ws()
+    stimuls = [] 
+    if @s.skip(/[{]/)
+      loop do
+        arr = scan_stimulation()
+        break unless arr
+        stimuls << arr
+      end
+      skip_ws()
+      return stimuls if @s.skip(/[}]/)
+    end
+
+    @s.pos = pos
+    return nil
+  end
+
+  # [weight@]at
+  # no skip_ws!
+  # 
+  def scan_stimulation
+    pos = @s.pos
+    skip_ws()
+
+    if at = scan_float()
+      if @s.skip(/@/) 
+        weight = at
+        if at = scan_float()
+          return at, weight
+        end
+      else
+        return at
+      end
+    end
+
+    @s.pos = pos
+    return nil
+  end
+
+  def scan_id
+    pos = @s.pos
+    skip_ws()
+    if @s.skip(/["]/)
+      id = @s.scan(/[^"]+/)
+      unless @s.skip(/["]/)
+        @s.pos = pos
+        id = nil
+      end
+    else
+      id = @s.scan(/\w+/)
+    end
+    return id
+  end
+
+  def scan_idlist
+    ids = []
+    loop do
+      id = scan_id()
+      break unless id
+      ids << id
+      skip_ws()
+      break unless @s.skip(/,/) # we expect a "," here
+    end
+    ids
+  end
+
+  def scan_type
+    skip_ws()
+    if    @s.skip(/[=]/) then :entity
+    elsif @s.skip(/->/)  then :connect
+    elsif @s.skip(/[!]/) then :stimulate
+    elsif @s.skip(/[<]/) then :template
+    else
+      nil
+    end
+  end
+end
+
+if __FILE__ == $0
+  s = YinScanner.new(<<-EOS)
+  #
+  # This is a comment
+  # This also.
+  #
+  # Command names like "TEMPLATE", "ENTITY", "CONNECT" and "STIMULATE"
+  # are optional.
+  #
+
+  TEMPLATE InputType < Neuron_Input {
+    const_threshold = +1.2e+200
+    last_spike_time = -Infinity
+  }
+
+  ENTITY Input1, "input2", Input2, Input3 = InputType
+  ENTITY Input4 = InputType
+
+  Input5, Input6 = Neuron_SRM01 {
+    mem_pot = 10.0
+  }
+
+  Syn1, Syn2, Syn3 = Synapse {
+    weight = 2.3
+    delay = 0.4
+  }
+
+  CONNECT Input1 -> Syn1, Syn2 -> Input5 
+
+  STIMULATE Input1, Input5 ! {
+    123@4.4 Inf@23.3 4.5  # weight defaults to Infinity
+  }
+  EOS
+  s.scan {|cmd| p cmd}
+end