CooCoo 0.1.0

data/lib/coo-coo/neuron_layer.rb

@@ -0,0 +1,168 @@
+require 'coo-coo/consts'
+require 'coo-coo/math'
+require 'coo-coo/debug'
+require 'coo-coo/layer_factory'
+require 'coo-coo/neuron'
+require 'coo-coo/sequence'
+require 'coo-coo/weight_deltas'
+
+module CooCoo
+  class NeuronLayer
+    LayerFactory.register_type(self)
+
+    attr_accessor :activation_function
+    
+    def initialize(num_inputs, size, activation_function = CooCoo.default_activation)
+      @activation_function = activation_function
+      @neurons = Array.new
+      size.times do |i|
+        @neurons[i] = Neuron.new(num_inputs, activation_function)
+      end
+    end
+
+    def neurons
+      @neurons
+    end
+    
+    def num_inputs
+      @neurons[0].num_inputs
+    end
+
+    def size
+      @neurons.size
+    end
+
+    def forward(input, hidden_state)
+      o = @neurons.each_with_index.inject(CooCoo::Vector.zeros(size)) do |acc, (neuron, i)|
+        acc[i] = neuron.forward(input)
+        acc
+      end
+
+      return o, hidden_state
+    end
+
+    def backprop(input, output, errors, hidden_state)
+      o = @neurons.each_with_index.inject(CooCoo::Vector.zeros(size)) do |acc, (n, i)|
+        acc[i] = n.backprop(input, output[i], errors[i])
+        acc
+      end
+
+      return o, hidden_state
+    end
+
+    def transfer_error(deltas)
+      @neurons.each_with_index.inject(CooCoo::Vector.zeros(num_inputs)) do |acc, (n, i)|
+        acc + n.transfer_error(deltas[i])
+      end
+    end
+
+    def transfer_input_error(expecting)
+      (output - expecting).to_a
+    end
+
+    def update_weights!(inputs, deltas)
+      adjust_weights!(weight_deltas(inputs, deltas))
+    end
+
+    def adjust_weights!(deltas)
+      @neurons.each_with_index do |n, i|
+        n.adjust_weights!(deltas.bias_deltas[i], deltas.weight_deltas[i])
+      end
+
+      self
+    end
+
+    def weight_deltas(inputs, deltas)
+      WeightDeltas.new(*@neurons.each_with_index.inject([ CooCoo::Vector.zeros(size), CooCoo::Sequence.new(size) ]) do |acc, (n, i)|
+                         acc[0][i], acc[1][i] = n.weight_deltas(inputs, deltas[i])
+                         acc
+                       end)
+    end
+
+    def to_hash(network = nil)
+      { type: self.class.to_s,
+        outputs: @neurons.size,
+        neurons: @neurons.collect(&:to_hash)
+      }
+    end
+
+    def resize!(new_size)
+      n = @neurons + Array.new(new_size - @neurons.size)
+      (@neurons.size...new_size).each do |i|
+        n[i] = Neuron.new(num_inputs)
+      end
+
+      @neurons = n
+
+      self
+    end
+
+    def update_neuron_from_hash!(neuron_index, h)
+      if neuron_index > @neurons.size
+        resize!(neuron_index)
+      end
+      
+      @neurons[neuron_index].update_from_hash!(h)
+    end
+
+    def update_from_hash!(h)
+      resize!(h[:outputs])
+      
+      h[:outputs].times do |i|
+        update_neuron_from_hash!(i, h[:neurons][i])
+      end
+
+      self
+    end
+
+    def ==(other)
+      other.kind_of?(self.class) &&
+        size == other.size &&
+        neurons.zip(other.neurons).all? { |a, b| a == b }
+    end
+    
+    class << self
+      def from_hash(h, network = nil)
+        self.new(h[:neurons].size, h[:outputs]).update_from_hash!(h)
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  layer = CooCoo::NeuronLayer.new(4, 2, CooCoo::ActivationFunctions.from_name(ENV.fetch("ACTIVATION", "Logistic")))
+  inputs = [ [ 1.0, 0.0, 0.0, 0.0 ],
+             [ 0.0, 0.0, 1.0, 0.0 ],
+             [ 0.0, 1.0, 0.0, 0.0],
+             [ 0.0, 0.0, 0.0, 1.0 ]
+           ].collect do |v|
+    CooCoo::Vector[v]
+  end
+  targets = [ [ 1.0, 0.0 ],
+              [ 0.0, 1.0 ],
+              [ 0.0, 0.0 ],
+              [ 0.0, 0.0 ]
+            ].collect do |v|
+    CooCoo::Vector[v]
+  end
+
+  inputs.zip(targets).cycle(ENV.fetch('LOOPS', 100).to_i).each do |(input, target)|
+    output, hidden_state = layer.forward(input, Hash.new)
+    puts("#{input} -> #{target}")
+    puts("\toutput: #{output}")
+
+    err = (output - target)
+    #err = err * err * 0.5
+    delta, hidden_state = layer.backprop(input, output, err, hidden_state)
+    puts("\tdelta: #{delta}")
+    puts("\terror: #{err}")
+    puts("\txfer: #{layer.transfer_error(delta)}")
+
+    layer.update_weights!(input, delta * 0.5)
+  end
+
+  inputs.zip(targets).each do |(input, target)|
+    output, hidden_state = layer.forward(input, Hash.new)
+    puts("#{input} -> #{output}\t#{target}")
+  end
+end

data/lib/coo-coo/option_parser.rb

@@ -0,0 +1,18 @@
+require 'optparse'
+
+module CooCoo
+  class OptionParser < ::OptionParser
+    def parse!(argv)
+      left_overs = []
+      begin
+        left_overs += super(argv)
+      rescue OptionParser::InvalidOption
+        left_overs += $!.args
+        left_overs << argv.shift
+        retry
+      end
+
+      left_overs
+    end
+  end
+end

data/lib/coo-coo/platform.rb

@@ -0,0 +1,17 @@
+module CooCoo
+	module Platform
+		def self.windows?
+			RbConfig::CONFIG['PLATFORM_DIR'] == 'win32'
+		end
+
+                ROOT = File.dirname(File.dirname(File.dirname(__FILE__)))
+                def self.root
+                  ROOT
+                end
+	end
+
+	def self.root
+		Platform.root
+	end
+end
+

data/lib/coo-coo/progress_bar.rb

@@ -0,0 +1,11 @@
+require 'ruby-progressbar'
+
+module CooCoo
+  module ProgressBar
+    Defaults = { :format => "%t %c/%C |%B| %a / %e" }
+
+    def self.create(opts)
+      ::ProgressBar.create(Defaults.merge(opts))
+    end
+  end
+end

data/lib/coo-coo/recurrence/backend.rb

@@ -0,0 +1,99 @@
+require 'coo-coo/math'
+require 'coo-coo/layer_factory'
+
+module CooCoo
+  module Recurrence
+    class Backend
+      LayerFactory.register_type(self)
+      
+      attr_reader :recurrence_layer
+      
+      def initialize(recurrence_layer, outputs, recurrent_outputs)
+        @recurrence_layer = recurrence_layer
+        @outputs = outputs
+        @recurrent_size = recurrent_outputs
+      end
+
+      def num_inputs
+        size + recurrent_size
+      end
+      
+      def size
+        @outputs
+      end
+
+      def recurrent_size
+        @recurrent_size
+      end
+
+      def activation_function
+        nil
+      end
+
+      def forward(inputs, hidden_state)
+        hidden_state ||= Hash.new
+        hidden_state[self] ||= Array.new
+        hidden_state[self].push(inputs[size, recurrent_size])
+
+        return inputs[0, size], hidden_state
+      end
+
+      def backprop(input, output, errors, hidden_state)
+        layer_state = hidden_state[@recurrence_layer]
+        rec_errors = (layer_state && layer_state.pop) || CooCoo::Vector.zeros(recurrent_size)
+        return errors.append(rec_errors), hidden_state
+      end
+
+      def transfer_error(deltas)
+        deltas
+      end
+
+      def update_weights!(inputs, deltas)
+        self
+      end
+
+      def adjust_weights!(deltas)
+        self
+      end
+
+      def weight_deltas(inputs, deltas)
+        inputs * deltas
+      end
+
+      def to_hash(network = nil)
+        { type: self.class.name,
+          outputs: @outputs,
+          recurrent_size: @recurrent_size,
+          recurrence_layer: network && network.layer_index(@recurrence_layer)
+        }
+      end
+
+      def ==(other)
+        other.kind_of?(self.class) &&
+          size = other.size &&
+          recurrence_layer == other.recurrence_layer &&
+          recurrent_size == other.recurrent_size
+      end
+      
+      def update_from_hash!(h)
+        @outputs = h.fetch(:outputs)
+        @recurrent_size = h.fetch(:recurrent_size)
+        self
+      end
+
+      def self.from_hash(h, network)
+        frontend = network.layers[h.fetch(:recurrence_layer)]
+        raise ArgumentError.new("Frontend not found") unless frontend
+        
+        layer = self.new(frontend,
+                         h.fetch(:outputs),
+                         h.fetch(:recurrent_size)).
+          update_from_hash!(h)
+
+        frontend.backend = layer
+        
+        layer
+      end
+    end
+  end
+end

data/lib/coo-coo/recurrence/frontend.rb

@@ -0,0 +1,101 @@
+require 'coo-coo/math'
+require 'coo-coo/layer_factory'
+require 'coo-coo/recurrence/backend'
+
+module CooCoo
+  module Recurrence
+    class Frontend
+      LayerFactory.register_type(self)
+
+      def initialize(num_inputs, num_recurrent_outputs)
+        @num_inputs = num_inputs
+        @num_recurrent_outputs = num_recurrent_outputs
+      end
+
+      def num_inputs
+        @num_inputs
+      end
+
+      def activation_function
+        nil
+      end
+
+      def size
+        @num_inputs + recurrent_size
+      end
+
+      def recurrent_size
+        @num_recurrent_outputs
+      end
+
+      def backend
+        @backend ||= Backend.new(self, @num_inputs, recurrent_size)
+      end
+
+      def backend=(layer)
+        @backend = layer
+      end
+
+      def forward(inputs, hidden_state)
+        layer_state = hidden_state[@backend]
+        recurrent_input = layer_state && layer_state.pop
+        return inputs.append(recurrent_input || empty_input), hidden_state
+      end
+
+      def backprop(input, outputs, errors, hidden_state)
+        # split for real and recurrent errors
+        norm_errors = errors[0, num_inputs]
+        recurrent_errors = errors[num_inputs, recurrent_size]
+
+        # buffer the recurrent output
+        hidden_state ||= Hash.new
+        hidden_state[self] ||= Array.new
+        hidden_state[self].push(recurrent_errors)
+
+        # return real errors
+        return norm_errors, hidden_state
+      end
+
+      def transfer_error(deltas)
+        deltas
+      end
+
+      def weight_deltas(inputs, deltas)
+        inputs * deltas
+      end
+
+      def adjust_weights!(deltas)
+        self
+      end
+
+      def ==(other)
+        other.kind_of?(self.class) &&
+          num_inputs == other.num_inputs &&
+          recurrent_size == other.recurrent_size
+      end
+      
+      def to_hash(network = nil)
+        { type: self.class.name,
+          inputs: @num_inputs,
+          recurrent_outputs: @num_recurrent_outputs
+        }
+      end
+
+      def update_from_hash!(h)
+        @num_inputs = h.fetch(:inputs)
+        @num_recurrent_outputs = h.fetch(:recurrent_outputs)
+
+        self
+      end
+
+      def self.from_hash(h, network = nil)
+        self.new(h.fetch(:inputs), h.fetch(:recurrent_outputs)).update_from_hash!(h)
+      end
+
+      private
+      def empty_input
+        CooCoo::Vector.zeros(recurrent_size)
+      end
+    end
+  end
+end

data/lib/coo-coo/sequence.rb

@@ -0,0 +1,187 @@
+require 'coo-coo/math'
+
+module CooCoo
+  class Sequence < Math::AbstractVector
+    def initialize(length, &init)
+      if length.kind_of?(Array)
+        @elements = length
+      else
+        @elements = Array.new(length, &init)
+      end
+    end
+
+    def self.[](value, max_size = nil)
+      self.new(value.to_a)
+      # ret = new(max_size || value.size)
+      # value.each_with_index do |v, i|
+      #   ret[i] = v
+      # end
+      # ret
+    end
+
+    # def coerce(other)
+    #   if other.respond_to?(:each)
+    #     return self.class[other], self
+    #   else
+    #     return self.class.new(self.size, other), self
+    #   end
+    # end
+    
+    def to_a
+      @elements
+    end
+
+    def to_s
+      values = each.collect do |e|
+        e.to_s
+      end
+
+      "[#{values.join(', ')}]"
+    end
+
+    def [](i, len = nil)
+      v = @elements[i, len || 1]
+      if len
+        self.class[v]
+      else
+        v[0]
+      end
+    end
+
+    def []=(i, v)
+      @elements[i] = v
+      self
+    end
+
+    def each(&block)
+      @elements.each(&block)
+    end
+
+    def each_with_index(&block)
+      each.each_with_index(&block)
+    end
+
+    include Enumerable
+
+    def collect(&block)
+      self.class[super]
+    end
+
+    def reverse
+      self.class[@elements.reverse]
+    end
+
+    def last(*args)
+      @elements.last(*args)
+    end
+
+    def append(other)
+      v = self.class.new(size + other.size)
+      each_with_index do |e, i|
+        v[i] = e
+      end
+      other.each_with_index do |e, i|
+        v[i + size] = e
+      end
+      v
+    end
+
+    def zero
+      self.class.new(size) do |i|
+        self[0].zero
+      end
+    end
+    
+    def sum
+      @elements.drop(1).inject(@elements[0]) do |acc, e|
+        acc + e
+      end
+    end
+
+    def average
+      sum / size.to_f
+    end
+
+    def sqrt
+      self.class[@elements.collect(&:sqrt)]
+    end
+
+    def -@
+      self.class[@elements.collect(&:-@)]
+    end
+    
+    def +(other)
+      v = if other.respond_to?(:each)
+            raise ArgumentError.new("Size mismatch: #{size} != #{other.size}") if size != other.size
+            other.each.zip(each).collect do |oe, se|
+          se + oe
+        end
+          else
+            each.collect do |e|
+          e + other
+        end
+          end
+      
+      self.class[v]
+    end
+
+    def -(other)
+      v = if other.respond_to?(:each)
+            raise ArgumentError.new("Size mismatch #{size} != #{other.size}") if size != other.size
+            other.each.zip(each).collect do |oe, se|
+          se - oe
+        end
+          else
+            each.collect do |e|
+          e - other
+        end
+          end
+      
+      self.class[v]
+    end
+
+    def size
+      @elements.size
+    end
+    
+    def length
+      @elements.size
+    end
+    
+    def *(other)
+      v = if other.respond_to?(:each)
+            raise ArgumentError.new("Size mismatch: #{size} != #{other.size}") if size != other.size
+            other.each.zip(each).collect do |oe, se|
+          se * oe
+        end
+          else
+            each.collect do |e|
+          e * other
+        end
+          end
+
+      self.class[v]
+    end
+
+    def /(other)
+      v = if other.respond_to?(:each)
+            raise ArgumentError.new("Size mismatch: #{size} != #{other.size}") if size != other.size
+            other.each.zip(each).collect do |oe, se|
+          se / oe
+        end
+          else
+            each.collect do |e|
+          e / other
+        end
+          end
+
+      self.class[v]
+    end
+
+    def ==(other)
+      other.size == size && each.zip(other.each).all? do |a, b|
+        a == b
+      end
+    end
+  end
+end