CooCoo 0.1.0

data/lib/coo-coo/fully_connected_layer.rb

@@ -0,0 +1,205 @@
+require 'coo-coo/consts'
+require 'coo-coo/math'
+require 'coo-coo/debug'
+require 'coo-coo/layer_factory'
+require 'coo-coo/weight_deltas'
+
+module CooCoo
+  class FullyConnectedLayer
+    LayerFactory.register_type(self)
+    
+    attr_reader :bias
+    attr_reader :weights
+    attr_reader :activation_function
+    
+    def initialize(num_inputs, size, activation_func = ActivationFunctions::Identity.instance, weights = nil, bias = nil)
+      @num_inputs = num_inputs
+      @size = size
+      @activation_function = activation_func
+      @weights = weights || @activation_function.initial_weights(num_inputs, size)
+      @bias = bias || @activation_function.initial_bias(size)
+    end
+
+    def activation_function
+      ActivationFunctions::Identity.instance
+    end
+    
+    def num_inputs
+      @num_inputs
+    end
+
+    def size
+      @size
+    end
+
+    def forward(input, hidden_state)
+      return @weights.dot(num_inputs, size, input, 1, num_inputs) + @bias, hidden_state
+    end
+
+    def backprop(input, output, errors, hidden_state)
+      return errors, hidden_state
+    end
+
+    def transfer_error(deltas)
+      deltas.dot(size, 1, @weights, num_inputs, size)
+    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)
+      @bias -= deltas.bias_deltas
+      @weights -= deltas.weight_deltas
+      self
+    end
+
+    def weight_deltas(inputs, deltas)
+      WeightDeltas.new(deltas, deltas.dot(1, size, inputs, num_inputs, 1))
+    end
+
+    def to_hash(network = nil)
+      { type: self.class.to_s,
+        outputs: size,
+        neurons: neuron_hash,
+        f: activation_function.name
+      }
+    end
+
+    def neuron_hash
+      @weights.each_slice(num_inputs).with_index.collect do |neuron_weights, i|
+        { num_inputs: num_inputs,
+          weights: neuron_weights.to_a,
+          bias: @bias[i]
+        }      
+      end
+    end
+
+    def add_neurons!(new_size)
+      if new_size != @size
+        w = CooCoo::Vector.zeros(num_inputs * new_size)
+        w[0, @weights.size] = @weights
+        w[@weights.size, num_inputs] = @activation_function.initial_weights(num_inputs, 1)
+        @weights = w
+
+        @bias = CooCoo::Vector.ones(new_size).set(@bias)
+        @bias[-1] = @activation_function.initial_bias(1)[0]
+        
+        @size = new_size
+      end
+      
+      self
+    end
+
+    def add_inputs!(new_size)
+      if new_size != num_inputs
+        w = CooCoo::Vector.zeros(new_size * size)
+        w.set2d!(new_size, @weights, num_inputs, 0, 0)
+        w.set2d!(new_size, @activation_function.initial_weights(size, 1), 1, new_size - 1, 0)
+        @weights = w
+        @num_inputs = new_size
+      end
+      
+      self
+    end
+
+    def update_neuron_from_hash!(neuron_index, h)
+      if neuron_index > size
+        add_neurons!(neuron_index)
+      end
+
+      @weights[neuron_index * num_inputs, num_inputs] = h[:weights]
+      @bias[neuron_index] = h[:bias]
+    end
+
+    def update_from_hash!(h)
+      add_neurons!(h[:outputs])
+      add_inputs!(h[:neurons][0][:num_inputs])
+      
+      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 &&
+        bias == other.bias &&
+        weights == other.weights &&
+        activation_function == other.activation_function
+    end
+    
+    class << self
+      def from_hash(h, network = nil)
+        self.new(h[:neurons][0][:num_inputs],
+                 h[:outputs],
+                 ActivationFunctions.from_name(h[:f] || 'Identity')).
+          update_from_hash!(h)
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  require 'coo-coo/network'
+  require 'coo-coo/linear_layer'
+
+  activation = ENV.fetch('ACTIVATION', 'Logistic')
+  net = CooCoo::Network.new
+  fc_layer = CooCoo::FullyConnectedLayer.new(4, 2, CooCoo::ActivationFunctions.from_name('Identity'), CooCoo::Vector.ones(4 * 2), CooCoo::Vector.ones(2))
+  net.layer(fc_layer)
+  net.layer(CooCoo::LinearLayer.new(2, CooCoo::ActivationFunctions.from_name(activation)))
+  
+  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::CUDA::Vector[v]
+  end
+  targets = [ [ 1.0, 0.0 ],
+              [ 0.0, 1.0 ],
+              [ 0.0, 0.0 ],
+              [ 0.0, 0.0 ]
+            ].collect do |v|
+    CooCoo::CUDA::Vector[v]
+  end
+
+  inputs.zip(targets).cycle(ENV.fetch('LOOPS', 100).to_i).each do |(input, target)|
+    output, hidden_state = net.forward(input, Hash.new)
+    puts("#{input} -> #{target} #{target.inspect}")
+    puts("\toutput: #{output}")
+
+    err = (output.last - target)
+    puts("\terr: #{err}")
+    #err = err * err * 0.5
+    delta, hidden_state = net.backprop(input, output, err, hidden_state)
+    puts("\tdelta: #{delta}")
+    puts("\terror: #{err}")
+    puts("\txfer: #{net.transfer_errors(delta)}")
+
+    net.update_weights!(input, output, delta * 0.5)
+  end
+
+  new_net = CooCoo::Network.new()
+  h = fc_layer.to_hash
+  h[:type] = 'CooCoo::VectorLayer'
+  h[:neurons].each do |n|
+    n[:f] = activation
+  end
+  new_net.layer(CooCoo::Layer.from_hash(h))
+
+  puts("\nInput\tFully\tVector\tTarget")
+  inputs.zip(targets).each do |(input, target)|
+    oa, hsa = net.forward(input, Hash.new)
+    ob, hsb = new_net.forward(input, Hash.new)
+    
+    puts("#{input} -> #{oa.last}\t#{ob.last}\t#{target}")
+  end
+end

data/lib/coo-coo/generation_script.rb

@@ -0,0 +1,38 @@
+require 'coo-coo/option_parser'
+
+module CooCoo
+  class GenerationScript
+    EvalBinding = Struct.new(:log)
+    EvalBinding.class_eval do
+      CooCoo = ::CooCoo
+      
+      def get_binding
+        binding
+      end
+    end
+
+    attr_reader :opts
+
+    def initialize(path, log)
+      @path = path
+      @log = log
+      load(path)
+    end
+
+    def load(path)
+      env = EvalBinding.new(@log)
+      @generator, @opts = eval(File.read(path), env.get_binding, path)
+      @path = path
+      self
+    end
+
+    def parse_args(argv)
+      @opts.parse!(argv)
+    end
+
+    def call(argv, *args)
+      argv = parse_args(argv)
+      [ argv, @generator.call(*args) ]
+    end
+  end
+end

data/lib/coo-coo/grapher.rb

@@ -0,0 +1,140 @@
+require 'coo-coo/dot'
+
+module CooCoo
+  class Grapher
+    def initialize()
+    end
+
+    def populate(name, network, edge_widths = nil)
+      Dot::Graph.new(:digraph, :label => name, :ranksep => 3) do |g|
+        populate_inputs(network.num_inputs, g)
+        populate_layers(network.layers, edge_widths, g)
+        populate_outputs(network.num_outputs, network.num_layers - 1, edge_widths, g)
+      end
+    end
+
+    def populate_layers(layers, edge_widths, g)
+      layers.each_with_index do |l, i|
+        populate_layer(l, i, edge_widths && edge_widths[i], g)
+      end
+    end
+    
+    def populate_inputs(num, g)
+      g.add_subgraph("cluster_inputs", :label => "Inputs", :rank => "same") do |sg|
+        inputs = num.times.collect do |i|
+          "input_#{i}"
+        end
+
+        sg.add_block("") do |ssg|
+          inputs.each_with_index do |name, i|
+            ssg.add_node(name, :label => i)
+          end
+          ssg.add_edge(inputs, :style => "invis")
+        end
+      end
+    end
+    
+    def populate_layer(layer, layer_index, edge_widths, g)
+      g.add_subgraph("cluster_layer_#{layer_index}", :label => "Layer #{layer_index}") do |sg|
+        sg.add_subgraph("layer_#{layer_index}", :rank => "same") do |ssg|
+          nodes = layer.neurons.each_with_index.collect do |n, ni|
+            name = "neuron_#{layer_index}_#{ni}"
+            populate_neuron_node(name, ni, ssg)
+            name
+          end
+          ssg.add_edge(nodes, :style => "invis")
+        end
+
+        layer.neurons.each_with_index do |n, ni|
+          populate_neuron_link(n, ni, layer_index, edge_widths, sg)
+        end
+      end
+    end
+
+    def populate_neuron_node(neuron_id, neuron_index, g)
+      g.add_node(neuron_id, :label => neuron_index)
+    end
+    
+    def populate_neuron_link(neuron, neuron_index, layer_index, edge_widths, g)
+      neuron.weights.each_with_index do |w, wi|
+        w = (edge_widths && edge_widths[wi]) || (w / 10.0)
+        #w = w / 10.0
+        
+        if layer_index == 0
+          g.add_edge([ "input_#{wi}", "neuron_#{layer_index}_#{neuron_index}" ],
+                     :penwidth => pen_scale(w.abs),
+                     :color => pen_color(w))
+        else
+          g.add_edge([ "neuron_#{layer_index - 1}_#{wi}", "neuron_#{layer_index}_#{neuron_index}"],
+                     :penwidth => pen_scale(w.abs),
+                     :color => pen_color(w))
+        end
+      end
+    end
+
+    def pen_color(x)
+      x = pen_scale(x)
+      color = NMatrix[[ 0, 0, 0 ]]
+
+      if x > 0.01
+        color = NMatrix[[ 1, 0, 0 ]]
+      elsif x < 0.01
+        color = NMatrix[[ 0, 0, 1 ]]
+      end
+
+      '#' + color.to_a.collect { |n| (n.abs * 255).to_i.to_s(16).rjust(2, "0") }.join
+    end
+
+    def populate_outputs(num_outputs, last_layer, edge_widths, g)
+      g.add_subgraph("cluster_outputs", :label => "Outputs") do |sg|
+        num_outputs.times do |o|
+          sg.add_node("output_#{o}", :label => o)
+        end
+      end
+      
+      num_outputs.times do |o|
+        w = edge_widths && edge_widths[-1][o] || 1.0
+        g.add_edge([ "neuron_#{last_layer}_#{o}", "output_#{o}" ],
+                   :penwidth => pen_scale(w.abs),
+                   :pencolor => pen_color(w))
+      end
+    end
+
+    def pen_scale(x)
+      x / 10.0
+    end
+  end
+
+  class OutputGrapher < Grapher
+    def populate(name, network, input_and_outputs)
+      super(name, network, input_and_outputs)
+    end
+
+    def pen_scale(x)
+      2.0 * x
+    end
+  end
+  
+end
+
+if __FILE__ == $0
+  require 'coo-coo'
+  net = CooCoo::Network.load(ARGV[0])
+  dw = CooCoo::Dot::Writer.new
+  ng = CooCoo::OutputGrapher.new
+  input = if ARGV[1]
+            ARGV[1].split.collect(&:to_f).to_nm([1, net.num_inputs])
+          else
+            m = NMatrix.zeros([1, net.num_inputs])            
+            m[0] = 1.0
+            m
+          end
+  target = NMatrix.zeros([1, net.num_outputs])
+  target[0] = 1.0
+  target[-1] = 1.0
+  outputs = net.forward(input)
+  deltas = net.backprop(outputs, target)
+  err = net.transfer_errors(deltas)
+  graph = ng.populate(ARGV[0], net, [ input ] + outputs)
+  dw.write(graph, $stdout)
+end

data/lib/coo-coo/image.rb

@@ -0,0 +1,286 @@
+require 'nmatrix'
+
+module CooCoo
+  module Image
+    class Base
+      attr_reader :width, :height, :bpp, :background
+      attr_accessor :repeat_x, :repeat_y
+      
+      def initialize(width, height, bpp = 1, pixels = nil, background = nil, repeat_x = false, repeat_y = false)
+        @width = width
+        @height = height
+        @bpp = bpp
+        @span = @width * @bpp
+        @background = background || bpp.times.collect { 0 }
+        @repeat_x = repeat_x
+        @repeat_y = repeat_y
+        @pixels = pixels || Array.new(@width * @height * @bpp, 0)
+      end
+
+      def [](x, y, byte = nil)
+        if (@repeat_x == false && (x < 0 || x >= width)) ||
+            (@repeat_y == false && (y < 0 || y >= height))
+          p = @background
+          if byte
+            p[byte]
+          else
+            p
+          end
+        else
+          i = pixel_index(x, y, byte || 0)
+          if byte
+            @pixels[i] || @background[byte]
+          else
+            p = @pixels[i, @bpp]
+            if p && !p.empty?
+              p
+            else
+              @background
+            end
+          end
+        end
+      end
+
+      def []=(x, y, v)
+        @bpp.times do |byte|
+          c = v
+          if v.respond_to?(:[])
+            c = v[byte]
+          end
+          @pixels[*pixel_index(x, y, byte)] = c
+        end
+      end
+
+      def *(transform)
+        TransformedImage.new(self, transform)
+      end
+
+      def filter(f)
+        TransformedImage.new(self, nil, f)
+      end
+
+      def to_a
+        @pixels.each_slice(@span).collect do |row|
+          if @bpp > 1
+            row.each_slice(@bpp).to_a
+          else
+            row.to_a
+          end
+        end
+      end
+
+      private
+      def pixel_index(x, y, byte = 0)
+        (byte || 0) + ((x.round % @width) * @bpp) + ((y.round % @height) * @span)
+      end
+    end
+
+    class TransformedImage
+      def initialize(image, transform, filter = nil)
+        @image = image
+        @transform = transform
+        @filter = filter
+      end
+
+      def width
+        @image.width
+      end
+
+      def height
+        @image.height
+      end
+
+      def bpp
+        @image.bpp
+      end
+
+      def *(transform)
+        t = if @transform
+              TransformChain.new(@transform, transform)
+            else
+              transform
+            end
+        TransformedImage.new(@image, t, @filter)
+      end
+
+      def to_a
+        height.times.collect do |y|
+          width.times.collect do |x|
+            self[x, y]
+          end.flatten
+        end
+      end
+      
+      def [](x, y, byte = nil)
+        x, y = *transform(x, y)
+        p = @image[x, y, byte]
+        filter(p, x, y)
+      end
+
+      def filter(pixel, x, y)
+        if @filter
+          @filter.call(pixel, x, y)
+        else
+          pixel
+        end
+      end
+      
+      def transform(x, y)
+        if @transform
+          @transform.call(x, y)
+        else
+          [ x, y ]
+        end
+      end
+    end
+
+    class Transform
+      def call(x, y)
+        [ x, y ]
+      end
+
+      def *(other)
+        TransformChain.new(self, other)
+      end
+    end
+    
+    class TransformChain < Transform
+      def initialize(first, second)
+        @first = first
+        @second = second
+      end
+      
+      def call(x, y)
+        p = @second.call(x, y)
+        p2 = @first.call(*p)
+        #puts("#{self.inspect} #{x} #{y} -> #{p} -> #{p2}")
+        p2
+      end
+    end
+
+    class Clipper < Transform
+      def initialize(width, height)
+        @width = width
+        @height = height
+      end
+
+      def call(pixel, x, y)
+        if x < 0 || x >= @width || y < 0 || y >= @height
+          Array.new(pixel.size, 0.0)
+        else
+          pixel
+        end
+      end
+    end
+    
+    class Translate < Transform
+      def initialize(tx, ty)
+        super()
+        @tx = tx
+        @ty = ty
+      end
+
+      def call(x, y)
+        [ x - @tx, y - @ty ]
+      end
+    end
+
+    class Scale < Transform
+      def initialize(sx, sy)
+        super()
+        @sx = sx
+        @sy = sy || sx
+      end
+
+      def call(x, y)
+        [ (x / @sx).floor, (y / @sy).floor ]
+      end
+    end
+
+    class Rotate < Transform
+      def initialize(ox, oy, radians)
+        super()
+        @ox = ox
+        @oy = oy
+        @radians = radians
+      end
+
+      def call(x, y)
+        c = ::Math.cos(@radians)
+        s = ::Math.sin(@radians)
+        
+        x = x - @ox
+        y = y - @oy
+
+        nx = x * c - y * s
+        ny = x * s + y * c
+        
+        nx = nx + @ox
+        ny = ny + @oy
+        
+        [ nx.floor, ny.floor ]
+      end
+    end
+  end
+end
+
+
+if __FILE__ == $0
+  def print_image(img)
+    img.height.times do |y|
+      puts(img.to_a[y].collect { |c| (c > 0.5)? 'X' : '.' }.join)
+    end
+  end
+
+  img = CooCoo::Image::Base.new(16, 16)
+  img.height.times do |i|
+    img[i, 0] = 1.0
+    img[0, i] = 1.0
+  end
+
+  puts("Image")
+  print_image(img)
+
+  t = CooCoo::Image::Translate.new(-3, -5)
+  puts("Translated")
+  print_image(img * t)
+
+  s = CooCoo::Image::Scale.new(2.0, 2.0)
+  puts("Scaled 2.0")
+  print_image(img * s)
+
+  s = CooCoo::Image::Scale.new(2.0, 2.0)
+  puts("Scaled 2.0 and transformed")
+  print_image(img * s * t)
+  puts("Translated and scaled 2.0")
+  print_image(img * t * s)
+
+  s = CooCoo::Image::Scale.new(0.5, 0.5)
+  puts("Scaled 0.5")
+  print_image(img * s)
+
+  r = CooCoo::Image::Rotate.new(img.width / 2.0, img.height / 2.0, ::Math::PI / 4.0)
+  puts("Rotated #{::Math::PI / 4.0} #{180.0 / 4.0}")
+  print_image(img * r)
+
+  r = CooCoo::Image::Rotate.new(0.0, 0.0, ::Math::PI / 3.0)
+  puts("Rotated #{::Math::PI / 3.0} #{180.0 / 3.0}")
+  print_image(img * r)
+
+  t = CooCoo::Image::Rotate.new(img.width / 2.0, img.height / 2.0, ::Math::PI / 3.0) * CooCoo::Image::Translate.new(3, 3)
+  puts("Rotated #{::Math::PI / 3.0} #{180.0 / 3.0}")
+  print_image(img * t)
+
+  c = CooCoo::Image::Clipper.new(8, 8)
+  puts("Clipped")
+  print_image(img.filter(c))
+  print_image(img.filter(c) * r)
+
+  RotationSteps = 7.0
+  (RotationSteps.to_i + 1).times do |i|
+    r = CooCoo::Image::Rotate.new(img.width / 2.0, img.height / 2.0, i * 2.0 * ::Math::PI / RotationSteps)
+    puts("#{i} Rotated #{i * 2.0 * ::Math::PI / RotationSteps} #{i * 360.0 / RotationSteps}")
+    print_image(img * r * s)
+    print_image(img * s * r)
+  end
+end