CooCoo 0.1.0

data/lib/coo-coo/layer.rb

@@ -0,0 +1,67 @@
+require 'coo-coo/consts'
+require 'coo-coo/math'
+require 'coo-coo/debug'
+require 'coo-coo/cuda'
+require 'coo-coo/layer_factory'
+require 'coo-coo/neuron_layer'
+require 'coo-coo/vector_layer'
+require 'coo-coo/linear_layer'
+require 'coo-coo/fully_connected_layer'
+
+module CooCoo
+  if ENV["COOCOO_USE_VECTOR"] != "0" # && (ENV["COOCOO_USE_CUDA"] != "0" && CooCoo::CUDA.available?)
+    Layer = CooCoo::VectorLayer
+  else
+    Layer = CooCoo::NeuronLayer
+  end
+
+  CooCoo.debug("Defined CooCoo::Layer as #{Layer}")
+
+  class << Layer
+    #def find_type(name)
+    #  LayerFactory.find_type(name)
+    # end
+    
+    # def from_hash(*args)
+    #  LayerFactory.from_hash(*args)
+    # end
+  end
+end
+
+if __FILE__ == $0
+  layer = CooCoo::Layer.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_with_index do |(input, target), i|
+    output, hidden_state = layer.forward(input, Hash.new)
+    puts("#{i}\t#{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/layer_factory.rb

@@ -0,0 +1,26 @@
+module CooCoo
+  module LayerFactory
+    class << self
+      attr_reader :types
+      
+      def register_type(klass)
+        @types ||= Hash.new
+        @types[klass.name.to_s] = klass
+        @types
+      end
+
+      def find_type(name)
+        @types && @types[name]
+      end
+      
+      def from_hash(h, network = nil)
+        klass = find_type(h[:type])
+        if klass
+          klass.from_hash(h, network)
+        else
+          raise ArgumentError.new("invalid layer type #{h[:type].inspect}")
+        end
+      end
+    end
+  end
+end

data/lib/coo-coo/linear_layer.rb

@@ -0,0 +1,59 @@
+require 'coo-coo/math'
+require 'coo-coo/activation_functions'
+require 'coo-coo/layer_factory'
+
+module CooCoo
+  class LinearLayer
+    LayerFactory.register_type(self)
+
+    attr_accessor :activation_function
+    attr_reader :size
+
+    def initialize(size, activation_function = CooCoo::ActivationFunctions::Identity.instance)
+      @size = size
+      @activation_function = activation_function
+    end
+
+    def num_inputs
+      size
+    end
+
+    def forward(input, hidden_state)
+      [ @activation_function.call(input), hidden_state ]
+    end
+
+    def backprop(input, output, errors, hidden_state)
+      [ errors * @activation_function.derivative(input, output), hidden_state ]
+    end
+
+    def transfer_error(deltas)
+      deltas
+    end
+
+    def adjust_weights!(deltas)
+      self
+    end
+
+    def weight_deltas(inputs, deltas)
+      deltas
+    end
+
+    def ==(other)
+      other.kind_of?(self.class) &&
+        num_inputs == other.num_inputs &&
+        size == other.size &&
+        activation_function == other.activation_function
+    end
+    
+    def to_hash(network = nil)
+      { type: self.class.name,
+        size: size,
+        f: @activation_function.name
+      }
+    end
+
+    def self.from_hash(h, network = nil)
+      new(h[:size], ActivationFunctions.from_name(h[:f]))
+    end
+  end
+end

data/lib/coo-coo/math.rb

@@ -0,0 +1,607 @@
+require 'coo-coo/core_ext'
+require 'coo-coo/math/abstract_vector'
+require 'coo-coo/math/functions'
+require 'coo-coo/math/interpolation'
+require 'coo-coo/cuda'
+require 'coo-coo/cuda/vector'
+
+module CooCoo
+  module Ruby
+    class Vector < CooCoo::Math::AbstractVector
+      def initialize(length, initial_value = 0.0, &block)
+        raise ArgumentError.new("Invalid size for a Vector") if length <= 0
+        
+        if block_given? # eat ruby's warning
+          @elements = Array.new(length, &block)
+        else
+          @elements = Array.new(length, initial_value)
+        end
+      end
+
+      def self.[](value, max_size = nil, default_value = 0.0)
+        if value.respond_to?(:[])
+          v = new(max_size || value.size, default_value) do |i|
+            value[i].to_f || default_value
+          end
+        else
+          v = new(max_size || value.size, default_value) do |i|
+            begin
+              value.next.to_f || default_value
+            rescue StopIteration
+              default_value
+            end
+          end
+        end
+      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)
+        i = size + i if i < 0
+        raise RangeError.new if i >= size || i < 0
+
+        v = @elements[i, len || 1]
+
+        if len
+          self.class[v]
+        elsif v
+          v[0]
+        end
+      end
+
+      def []=(i, l, v = nil)
+        i = size + i if i < 0
+        raise RangeError.new if i >= size || i < 0
+
+        if v
+          @elements[i, l] = v
+        else
+          @elements[i] = l
+        end
+      end
+
+      def set(values)
+        values = [ values ].cycle(size) if values.kind_of?(Numeric)
+        
+        values.each_with_index do |v, i|
+          break if i >= @elements.size
+          @elements[i] = v
+        end
+
+        self
+      end
+
+      def each(&block)
+        @elements.each(&block)
+      end
+
+      def each_with_index(&block)
+        each.each_with_index(&block)
+      end
+
+      def each_slice(n, &block)
+        if block
+          num_slices = (size / n.to_f).ceil.to_i
+          
+          @elements.each_slice(n).with_index do |slice, i|
+            block.call(self.class[slice, n])
+          end
+        else
+          to_enum(__method__, n)
+        end
+      end
+
+      def resize(new_size)
+        if new_size > size
+          @elements = @elements + Array.new(new_size - size)
+        elsif new_size < size
+          @elements = @elements[0, new_size]
+        end
+      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 sum
+        @elements.each.sum
+      end
+
+      def magnitude_squared
+        (self * self).sum
+      end
+
+      def magnitude
+        magnitude_squared.sqrt
+      end
+
+      def normalize
+        self / magnitude
+      end
+      
+      def dot(width, height, other, owidth = nil, oheight = nil)
+        if other.kind_of?(self.class) || other.respond_to?(:[])
+          owidth ||= width
+          oheight ||= height
+
+          if width * height != size
+            raise ArgumentError.new("width & height, #{width}x#{height} don't match our size: #{size}")
+          end
+          if owidth * oheight != other.size
+            raise ArgumentError.new("owidth & oheight, #{owidth}x#{oheight} don't match the argument's size: #{other.size}")
+          end
+
+          if width != oheight
+            raise ArgumentError.new("argument's height != this' width")
+          end
+
+          self.class[height.times.collect do |row|
+                       owidth.times.collect do |col|
+                         oheight.times.collect do |i|
+                           self[row * width + i] * other[i * owidth + col]
+                         end.sum
+                       end
+                     end.flatten]
+        else
+          raise ArgumentError.new("argument must be a #{self.class} or enumerable")
+        end
+      end
+
+      def +(other)
+        v = if other.respond_to?(:each)
+              raise ArgumentError.new("Size mismatch") 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 -@
+        self * -1.0
+      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") 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") 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") 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 == other.size && each.zip(other.each).all? do |a, b|
+          a == b || (a.nan? && b.nan?)
+        end || false
+      rescue NoMethodError
+        false
+      end
+
+      def !=(other)
+        !(self == other)
+      end
+
+      [ :<, :<=, :>=, :> ].each do |comp|
+        define_method(comp) do |other|
+          if other.respond_to?(:each)
+            self.class[each.zip(other.each).collect do |a, b|
+                         a.send(comp, b) ? 1.0 : 0.0
+                       end]
+          else
+  	    self.class[each.collect { |a| a.send(comp, other) ? 1.0 : 0.0 }]
+          end
+        end
+      end
+
+      [ :abs, :floor, :ceil, :round
+      ].each do |func|
+        define_method(func) do
+          self.class[@elements.collect { |v| v.send(func) }]
+        end
+      end
+
+      [ :exp,
+        :sin, :cos, :tan, :asin, :acos, :atan,
+        :sinh, :cosh, :tanh, :asinh, :acosh, :atanh
+      ].each do |func|
+        define_method(func) do
+          self.class[@elements.collect { |v|
+                       begin
+                         ::Math.send(func, v)
+                       rescue ::Math::DomainError
+                         Float::NAN
+                       end
+                     }]
+        end
+      end
+    end
+  end
+
+  module NMatrix
+    require 'nmatrix'
+    
+    class Vector < CooCoo::Math::AbstractVector
+      protected
+      attr_reader :elements
+
+      public
+      
+      def initialize(length, initial_value = 0.0, &block)
+        if length != nil
+          if length <= 0
+            raise ArgumentError.new("size must be larger than zero")
+          end
+          @elements = ::NMatrix.new([ 1, length ], initial_value)
+          if block
+            @elements.size.times do |i|
+              @elements[i] = block.call(i)
+            end
+          end
+        end
+      end
+
+      def self.[](value, max_size = nil, default_value = 0.0)
+        if value.kind_of?(::NMatrix)
+          v = new(nil)
+          v.instance_variable_set('@elements', value)
+          v
+        elsif value.respond_to?(:[])
+          v = new(max_size || value.size, default_value) do |i|
+            value[i] || default_value
+          end
+        else
+          v = new(max_size || value.size, default_value) do |i|
+            begin
+              value.next || default_value
+            rescue StopIteration
+              default_value
+            end
+          end
+        end
+      end
+
+      def self.zeros(length)
+        self[::NMatrix.zeros([1, length])]
+      end
+
+      def self.ones(length)
+        self[::NMatrix.ones([1, length])]
+      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.to_a
+      end
+
+      def to_s
+        "[" + to_a.join(", ") + "]"
+      end
+
+      def _dump(depth)
+        @elements.to_a.pack('E*')
+      end
+
+      def self._load(args)
+        arr = args.unpack('E*')
+        self[arr]
+      end
+
+      def [](i, len = nil)
+        i = size + i if i < 0
+        raise RangeError.new if i >= size || i < 0
+
+        if len
+          len = (size - i) if (i + len) >= size
+          raise ArgumentError.new("length must be > 0") if len <= 0
+        end
+        
+        v = @elements[0, (i...(i + (len || 1))) ]
+        
+        if len
+          self.class[v]
+        else
+          v[0]
+        end
+      end
+
+      def []=(i, l, v = nil)
+        i = size + i if i < 0
+        raise RangeError.new if i >= size || i < 0
+
+        if v
+          @elements[i, l] = v
+        else
+          @elements[i] = l
+        end
+        # @elements[i] = v
+      end
+
+      def set(values)
+        values = [ values ].each.cycle(size) if values.kind_of?(Numeric)
+        
+        values.each_with_index do |v, i|
+          break if i >= @elements.size
+          @elements[i] = v
+        end
+
+        self
+      end
+
+      def append(other)
+        if other.kind_of?(self.class)
+          self.class[@elements.concat(other.elements)]
+        else
+          append(self.class[other])
+        end
+      end
+      
+      def each(&block)
+        @elements.each(&block)
+      end
+
+      def each_with_index(&block)
+        @elements.each_with_index(&block)
+      end
+
+      def each_slice(n, &block)
+        if block
+          last_slice = (size / n.to_f).ceil.to_i
+          
+          @elements.each_slice(n).with_index do |slice, i|
+            if i == last_slice - 1
+              slice = slice + Array.new(n - slice.size)
+            end
+            
+            block.call(self.class[slice])
+          end
+        else
+          to_enum(__method__, n)
+        end
+      end
+
+      def sum
+        @elements.each.sum
+      end
+
+      def magnitude_squared
+        (self * self).sum
+      end
+
+      def magnitude
+        magnitude_squared.sqrt
+      end
+
+      def normalize
+        self / magnitude
+      end
+      
+      def dot(width, height, other, owidth, oheight)
+        owidth ||= width
+        oheight ||= height
+        
+        if other.kind_of?(self.class)
+          raise ArgumentError.new("invalid size") if other.size != owidth * oheight
+          raise ArgumentError.new("invalid size") if size != width * height
+
+          product = @elements.reshape([ height, width ]).
+            dot(other.elements.reshape([ oheight, owidth ]))
+          
+          self.class[product.
+                     reshape([1, height * owidth ])]
+        else
+          self.dot(width, height, self.class[other], owidth, oheight)
+        end
+      end
+
+      def +(other)
+        if other.kind_of?(self.class)
+          self.class[@elements + other.elements]
+        elsif other.kind_of?(Numeric)
+          self.class[@elements + other]
+        else
+          self + self.class[other]
+        end
+      end
+
+      def -@
+        self * -1.0
+      end
+      
+      def -(other)
+        if other.kind_of?(self.class)
+          self.class[@elements - other.elements]
+        elsif other.kind_of?(Numeric)
+          self.class[@elements - other]
+        else
+          self - self.class[other]
+        end
+      end
+
+      def size
+        length
+      end
+      
+      def length
+        @elements.shape[1]
+      end
+      
+      def *(other)
+        if other.kind_of?(self.class)
+          self.class[@elements * other.elements]
+        elsif other.kind_of?(Numeric)
+          self.class[@elements * other]
+        else
+          self * self.class[other]
+        end
+      end
+
+      def **(other)
+        if other.kind_of?(self.class)
+          self.class[@elements ** other.elements]
+        elsif other.kind_of?(Numeric)
+          self.class[@elements ** other]
+        else
+          self ** self.class[other]
+        end
+      end
+      
+      def /(other)
+        if other.kind_of?(self.class)
+          self.class[@elements / other.elements]
+        elsif other.kind_of?(Numeric)
+          self.class[@elements / other]
+        else
+          self / self.class[other]
+        end
+      end
+
+      def ==(other)
+        if other.kind_of?(self.class)
+          size == other.size && @elements == other.elements
+        elsif other != nil
+          a, b = coerce(other)
+          a == b
+        else
+          false
+        end
+      end
+
+      [ :<, :<=, :>=, :> ].each do |comp|
+        define_method(comp) do |other|
+          if other.kind_of?(self.class)
+            self.class[(@elements.send(comp, other.elements)).collect do |v|
+                         v ? 1.0 : 0.0
+                       end]
+          else
+            self.class[(@elements.send(comp, other)).collect do |v|
+                         v ? 1.0 : 0.0
+                       end]
+          end
+        end
+      end
+
+      [ :abs, :exp,
+        :floor, :ceil, :round,
+        :sin, :cos, :tan, :asin, :acos, :atan,
+        :sinh, :cosh, :tanh, :asinh, :acosh, :atanh
+      ].each do |func|
+        define_method(func) do
+          begin
+            self.class[@elements.send(func)]
+          rescue ::Math::DomainError
+            self.class[CooCoo::Ruby::Vector[self.to_a].send(func)]
+          end
+        end
+      end
+
+      protected
+      def elements
+        @elements
+      end
+    end
+  end
+
+  if ENV["COOCOO_USE_CUDA"] != "0" && CooCoo::CUDA.available?
+    Vector = CUDA::Vector
+  else
+    Vector = Ruby::Vector
+    #Vector = NMatrix::Vector
+  end
+end