CooCoo 0.1.0

data/examples/cifar/cifar.rb

@@ -0,0 +1,94 @@
+module CooCoo::Cifar
+  ROOT = Pathname.new(__FILE__).dirname
+  BINARY_BATCHES = {
+    labels: ROOT.join("cifar-10-batches-bin", "batches.meta.txt"),
+    batches: 5.times.collect { |i| ROOT.join("cifar-10-batches-bin", "data_batch_#{i + 1}.bin") },
+    test_batch: ROOT.join("cifar-10-batches-bin", "test_batch.bin")
+  }
+
+  class LabelSet
+    def initialize(path = BINARY_BATCHES[:labels])
+      load!(path)
+    end
+
+    def load!(path)
+      @labels = File.read(path).split("\n")
+    end
+
+    def [](number)
+      @labels[number]
+    end
+  end
+  
+  class Batch
+    WIDTH = 32
+    HEIGHT = 32
+    NUM_PIXELS = WIDTH * HEIGHT
+    NUM_CHANNELS = 3
+
+    attr_reader :paths
+    
+    def initialize(*paths)
+      paths = BINARY_BATCHES[:batches] if paths.empty?
+      @paths = Array.new
+      paths.each do |p|
+        add(p)
+      end
+    end
+
+    def add(path)
+      @paths << path
+      self
+    end
+
+    def each(&block)
+      return to_enum(__method__) unless block_given?
+
+      @paths.each_with_index do |path, i|
+        enumerate_file(path, i, &block)
+      end
+    end
+
+    def enumerate_file(path, index, &block)
+      $stderr.puts("Loading #{path}")
+      File.open(path, 'rb') do |f|
+        i = 0
+        loop do
+          data = f.read(1 + NUM_PIXELS * NUM_CHANNELS)
+          break unless data
+
+          data = data.unpack('C*')
+          label = data[0]
+          red = data[1, NUM_PIXELS]
+          green = data[1 + NUM_PIXELS, NUM_PIXELS]
+          blue = data[1 + NUM_PIXELS * 2, NUM_PIXELS]
+          block.call(index, i, label, red, green, blue)
+          i += 1
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  require 'chunky_png'
+  
+  c = CooCoo::Cifar::Batch.new
+  labels = CooCoo::Cifar::LabelSet.new
+  first, count = ARGV.collect(&:to_i)
+  first ||= 0
+  count ||= 32
+  puts("Showing #{count}, skipping #{first}")
+  c.each.drop(first).first(count).each do |batch, i, label, red, green, blue|
+    file = "#{batch}-#{i}-#{labels[label]}.png"
+    puts(file)
+    png = ChunkyPNG::Image.new(32, 32)
+    32.times do |y|
+      32.times do |x|
+        p = y * 32 + x
+        png[x, y] = ChunkyPNG::Color.rgb(red[p], green[p], blue[p])
+      end
+    end
+    png.save(file, :interlace => true)
+  end
+end

data/examples/img-similarity.rb

@@ -0,0 +1,201 @@
+require 'coo-coo'
+require 'chunky_png'
+
+class ImageStream
+  attr_reader :images
+  
+  def initialize(*images)
+    @images = images.collect { |i| load_image(i) }
+  end
+
+  def load_image(path)
+    png = ChunkyPNG::Image.from_file(path)
+    pixels = CooCoo::Vector.new(png.width * png.height * 3)
+    png.pixels.each_slice(png.width).with_index do |row, i|
+      pixels[i * png.width * 3, png.width * 3] = row.
+        collect { |p| [ ChunkyPNG::Color.r(p),
+                        ChunkyPNG::Color.g(p),
+                        ChunkyPNG::Color.b(p)
+                      ] }.
+        flatten
+    end
+    
+    [ path, png.width, png.height, pixels / 256.0 ]
+  end
+
+  def size
+    @images.size
+  end
+
+  def channels
+    3
+  end
+  
+  def each(&block)
+    return to_enum(__method__) unless block_given?
+
+    @images.each do |img|
+      yield(*img)
+    end
+  end
+end
+
+class ImageSlicer
+  attr_reader :slice_width
+  attr_reader :slice_height
+  
+  def initialize(num_slices, slice_width, slice_height, image_stream, chitters = 0)
+    @num_slices = num_slices
+    @slice_width = slice_width
+    @slice_height = slice_height
+    @chitters = chitters
+    @stream = image_stream
+  end
+
+  def size
+    @num_slices * @stream.size * @chitters
+  end
+
+  def channels
+    @stream.channels
+  end
+
+  def each(&block)
+    return to_enum(__method__) unless block_given?
+
+    @num_slices.times do |n|
+      @stream.each.with_index do |(path, width, height, pixels), i|
+        xr = rand(width)
+        yr = rand(height)
+        half_w = @slice_width / 2
+        half_h = @slice_height / 2
+        @chitters.times do |chitter|
+          x = xr
+          x += rand(@slice_width) - half_w if @chitters > 1
+          x = width - @slice_width if x + @slice_width > width
+          y = yr
+          y += rand(@slice_height) - half_h if @chitters > 1
+          y = height - @slice_height if y + @slice_height > height
+
+          slice = pixels.slice_2d(width * channels, height, x, y, @slice_width * channels, @slice_height)
+          yield(path, slice, x, y)
+        end
+      end
+    end
+  end
+end
+
+class TrainingSet
+  attr_reader :slicer, :batch_size
+  
+  def initialize(slicer, batch_size)
+    @slicer = slicer
+    @batch_size = batch_size
+  end
+
+  def size
+    @slicer.size
+  end
+  
+  def output_size
+    3
+  end
+
+  def input_size
+    2 * @slicer.channels * @slicer.slice_width * @slicer.slice_height
+  end
+
+  def interleave(a, b)
+    img = CooCoo::Vector.zeros(input_size)
+    stride = @slicer.slice_width * @slicer.channels
+
+    @slicer.slice_height.times do |y|
+      row = y * stride
+      img[2 * row, stride] = a[row, stride]
+      img[2 * row + stride, stride] = b[row, stride]
+    end
+    
+    img
+  end
+  
+  def each(&block)
+    return to_enum(__method__) unless block_given?
+
+    @slicer.each.each_slice(@batch_size) do |batch|
+      batch.shuffle.zip(batch.shuffle) do |a, b|
+        yield([target_for(a, b), interleave(a[1], b[1])])
+      end
+    end
+  end
+
+  def target_for(a, b)
+    v = CooCoo::Vector.zeros(output_size)
+    if a[0] == b[0]
+      v[0] = 1.0
+      d = CooCoo::Vector[[b[2] - a[2], b[3] - a[3]]]
+      d = d.magnitude
+      v[1] = @slicer.slice_width.to_f / d - 1.0
+      v[1] = 1.0 if v[1] > 1.0
+      v[1] = 0.0 if v[1] <= 0.0
+      v[2] = @slicer.slice_height.to_f / d - 1.0
+      v[2] = 1.0 if v[2] > 1.0
+      v[2] = 0.0 if v[2] <= 0.0
+    end
+    v
+  end
+end
+
+if $0 != __FILE__
+  require 'pathname'
+  require 'ostruct'
+
+  @options = OpenStruct.new
+  @options.slice_width = 32
+  @options.slice_height = 32
+  @options.num_slices = 1000
+  @options.cycles = 100
+  @options.images = []
+  @options.chitters = 4
+
+  @opts = CooCoo::OptionParser.new do |o|
+    o.banner = "Image Similarity Data Generator options"
+    
+    o.on('--data-path PATH') do |path|
+      @options.images += Dir.glob(path)
+    end
+
+    o.on('--data-slice-width SIZE') do |n|
+      @options.slice_width = n.to_i
+    end
+
+    o.on('--data-slice-height SIZE') do |n|
+      @options.slice_height = n.to_i
+    end
+
+    o.on('--data-slices NUM') do |n|
+      @options.num_slices = n.to_i
+    end
+
+    o.on('--data-cycles NUM') do |n|
+      @options.cycles = n.to_i
+    end
+
+    o.on('--data-chitters NUM') do |n|
+      @options.chitters = n.to_i
+    end
+  end
+
+  def training_set()
+    stream = ImageStream.new(*@options.images)
+    slicer = ImageSlicer.new(@options.cycles,
+                             @options.slice_width,
+                             @options.slice_height,
+                             stream,
+                             @options.chitters)
+    training_set = TrainingSet.new(slicer, @options.num_slices.to_i)
+
+    training_set
+  end
+
+  [ method(:training_set), @opts ]
+end

data/examples/math_ops.rb

@@ -0,0 +1,57 @@
+#!/bin/env ruby
+
+require 'coo-coo'
+
+average = Proc.new do |m|
+  e = m.each
+  Vector[[e.sum / e.count]]
+end
+
+xor = Proc.new do |m|
+  Vector[[m.to_a.flatten.inject(0) { |acc, n| acc ^ (255.0 * n).to_i } / 256.0]]
+end
+
+max = Proc.new do |m|
+  Vector[[m.each.max]]
+end
+
+def data(n, &block)
+  raise ArgumentError.new("Block not given") unless block_given?
+
+  out = Array.new
+  n.times do
+    m = Vector.rand(3)
+    out << [ block.(m), m ]
+  end
+  
+  out
+end
+
+def print_prediction(model, input, expecting)
+  output = model.forward(input)
+  puts("#{input} -> #{output}, expecting #{expecting}, #{expecting - output}")
+end
+
+Random.srand(123)
+
+f = max
+training_data = data(1000, &f)
+model = CooCoo::Network.new()
+model.layer(CooCoo::Layer.new(3, 8))
+model.layer(CooCoo::Layer.new(8, 8))
+model.layer(CooCoo::Layer.new(8, 1))
+
+puts("Training")
+now = Time.now
+model.train(network: model,
+            data: training_data,
+            learning_rate: 0.3,
+            batch_size: 200)
+puts("\tElapsed #{(Time.now - now) / 60.0} min")
+
+puts("Predicting:")
+
+print_prediction(model, training_data.first[1], training_data.first[0])
+print_prediction(model, Vector[[0.5, 0.75, 0.25]], f.(Vector[[0.5, 0.75, 0.25]]))
+print_prediction(model, Vector[[0.25, 0.0, 0.0]], f.(Vector[[0.25, 0.0, 0.0]]))
+print_prediction(model, Vector[[1.0, 0.0, 0.0]], f.(Vector[[1.0, 0.0, 0.0]]))

data/examples/mnist.rb

@@ -0,0 +1,365 @@
+require 'pathname'
+require 'net/http'
+require 'zlib'
+require 'coo-coo/image'
+
+module MNist
+  PATH = Pathname.new(__FILE__)
+  MNIST_URIS = [ "http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz",
+                 "http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz",
+                 "http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz",
+                 "http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz"
+               ]
+  TRAIN_LABELS_PATH = PATH.dirname.join('train-labels-idx1-ubyte')
+  TRAIN_IMAGES_PATH = PATH.dirname.join('train-images-idx3-ubyte')
+  TEST_LABELS_PATH = PATH.dirname.join('t10k-labels-idx1-ubyte')
+  TEST_IMAGES_PATH = PATH.dirname.join('t10k-images-idx3-ubyte')
+
+  Width = 28
+  Height = 28
+
+  module Fetcher
+    def fetch_gzip_url(url)
+      data = Net::HTTP.get(url)
+      Zlib::GzipReader.new(StringIO.new(data)).read
+    end
+    
+    def fetch!
+      MNIST_URIS.each do |uri|
+        uri = URI.parse(uri)
+        path = PATH.dirname.join(File.basename(uri.path).sub(".gz", ""))
+        data = fetch_gzip_url(uri)
+        File.open(path, "w") do |f|
+          f.write(data)
+        end
+      end
+    end
+  end
+  
+  class Example
+    attr_accessor :label
+    attr_accessor :pixels
+    attr_accessor :angle
+    attr_accessor :offset_x
+    attr_accessor :offset_y
+
+    def initialize(label, pixels, angle = 0, offset_x = 0, offset_y = 0)
+      @label = label
+      @pixels = pixels
+      @angle = angle
+      @offset_x = offset_x
+      @offset_y = offset_y
+    end
+
+    def pixel(x, y)
+      @pixels[y * MNist::Width + x] || 0
+    end
+
+    def to_ascii
+      s = ""
+      28.times do |y|
+        28.times do |x|
+          s += char_for_pixel(pixel(x, y))
+        end
+        s += "\n"
+      end
+      s
+    end
+
+    def each_pixel(&block)
+      return to_enum(__method__) unless block_given?
+      28.times do |y|
+        28.times do |x|
+          yield(pixel(x, y))
+        end
+      end
+    end
+    
+    private
+    PixelValues = ' -+X#'
+
+    def char_for_pixel(p)
+      PixelValues[(p / 256.0 * PixelValues.length).to_i]
+    end
+  end
+
+  class DataStreamer
+    def initialize(labels_path, images_path)
+      @labels, @size = open_labels(labels_path)
+      @images, @image_size = open_images(images_path)
+    end
+
+    def close
+      @labels.close
+      @images.close
+    end
+    
+    def size
+      @size
+    end
+
+    def next
+      label = next_label
+      pixels = next_image
+      if label && pixels
+        Example.new(label, pixels)
+      end
+    end
+    
+    private
+    
+    def open_labels(path)
+      f = File.open(path, "rb")
+      magic, number = f.read(4 * 2).unpack('NN')
+      raise RuntimeError.new("Invalid magic number #{magic} in #{path}") if magic != 0x801
+      
+      [ f, number ]
+    end
+    
+    def next_label
+      l = @labels.read(1)
+      if l
+        l.unpack('C').first
+      else
+        nil
+      end
+    end
+
+    def open_images(path)
+      f = File.open(path, "rb")
+      magic, num_images, height, width = f.read(4 * 4).unpack('NNNN')
+      raise RuntimeError.new("Invalid magic number #{magic} in #{path}") if magic != 0x803
+
+      [ f, width * height * 1 ]
+    end
+
+    def next_image
+      p = @images.read(@image_size)
+      if p
+        p.unpack('C' * @image_size)
+      else
+        nil
+      end
+    end
+  end
+
+  class DataStream
+    def initialize(labels_path = TRAIN_LABELS_PATH, images_path = TRAIN_IMAGES_PATH)
+      if (labels_path == TRAIN_LABELS_PATH && images_path == TRAIN_IMAGES_PATH) ||
+         (labels_path == TEST_LABELS_PATH && images_path == TEST_IMAGES_PATH)
+        if !File.exists?(labels_path) || !File.exists?(images_path)
+          Fetcher.fetch!
+        end
+      end
+
+      raise ArgumentError.new("File does not exist: #{labels_path}") unless File.exists?(labels_path)
+      raise ArgumentError.new("File does not exist: #{images_path}") unless File.exists?(images_path)
+      
+      @labels_path = labels_path
+      @images_path = images_path
+
+      read_metadata
+    end
+
+    attr_reader :size
+    attr_reader :width
+    attr_reader :height
+    
+    def each(&block)
+      return enum_for(__method__) unless block_given?
+
+      begin
+        streamer = DataStreamer.new(@labels_path, @images_path)
+        
+        begin
+          ex = streamer.next
+          if ex
+            block.call(ex)
+          end
+        end until ex == nil
+      ensure
+        streamer.close
+      end
+    end
+
+    def to_enum
+      each
+    end
+
+    private
+    def read_metadata
+      read_size
+      read_dimensions
+    end
+
+    def read_dimensions
+      File.open(@images_path, "rb") do |f|
+        magic, num_images, height, width = f.read(4 * 4).unpack('NNNN')
+        raise RuntimeError.new("Invalid magic number #{magic} in #{path}") if magic != 0x803
+
+        @width = width
+        @height = height
+      end
+    end
+    
+    def read_size
+      File.open(@labels_path, "rb") do |f|
+        magic, number = f.read(4 * 2).unpack('NN')
+        raise RuntimeError.new("Invalid magic number #{magic} in #{@labels_path}") if magic != 0x801
+
+        @size = number
+      end
+    end
+
+    public
+    class Rotator < Enumerator
+      def initialize(data, rotations, rotation_range, random = false)
+        @data = data.to_enum
+        @rotations = rotations
+        @rotation_range = rotation_range
+        @random = random
+        
+        super() do |y|
+          loop do
+            example = @data.next
+            @rotations.times do |r|
+              t = if @random
+                    rand
+                  else
+                    (r / @rotations.to_f)
+                  end
+              theta = t * @rotation_range - @rotation_range / 2.0
+              img = rotate_pixels(example.pixels, theta)
+              y << Example.new(example.label, img.to_a.flatten, theta)
+            end
+          end
+        end
+      end
+
+      def wrap(enum)
+        self.class.new(enum, @rotations, @rotation_range, @random)
+      end
+      
+      def drop(n)
+        wrap(@data.drop(n))
+      end
+
+      def rotate_pixels(pixels, theta)
+        rot = CooCoo::Image::Rotate.new(MNist::Width / 2, MNist::Height / 2, theta)
+        img = CooCoo::Image::Base.new(MNist::Width, MNist::Height, 1, pixels.to_a.flatten)
+        (img * rot)
+      end
+    end
+
+    class Translator < Enumerator
+      def initialize(data, num_translations, dx, dy, random = false)
+        @data = data.to_enum
+        @num_translations = num_translations
+        @dx = dx
+        @dy = dy
+        @random = random
+        
+        super() do |yielder|
+          loop do
+            example = @data.next
+            @num_translations.times do |r|
+              x = if @random
+                    rand
+                  else
+                    (r / @num_translations.to_f)
+                  end
+              x = x * @dx - @dx / 2.0
+              y = if @random
+                    rand
+                  else
+                    (r / @num_translations.to_f)
+                  end
+              y = y * @dy - @dy / 2.0
+              img = translate_pixels(example.pixels, x, y)
+              yielder << Example.new(example.label, img.to_a.flatten, example.angle, x, y)
+            end
+          end
+        end
+      end
+
+      def wrap(enum)
+        self.class.new(enum, @num_translations, @dx, @dy, @random)
+      end
+      
+      def drop(n)
+        wrap(@data.drop(n))
+      end
+
+      def translate_pixels(pixels, x, y)
+        transform = CooCoo::Image::Translate.new(x, y)
+        img = CooCoo::Image::Base.new(MNist::Width, MNist::Height, 1, pixels.to_a.flatten)
+        (img * transform)
+      end
+    end
+  end
+
+  class TrainingSet
+    def initialize(data_stream = MNist::DataStream.new(MNist::TRAIN_LABELS_PATH, MNist::TRAIN_IMAGES_PATH))
+      @stream = data_stream
+    end
+
+    def each(&block)
+      return to_enum(__method__) unless block
+
+      enum = @stream.each
+      loop do
+        example = enum.next
+
+        a = Array.new(10, 0.0)
+        a[example.label] = 1.0
+        m = [ CooCoo::Vector[a],
+              CooCoo::Vector[example.pixels] / 256.0
+        ]
+        #$stderr.puts("#{m[0]}\t#{m[1]}")
+        block.call(m)
+      end
+    end
+  end
+
+  class DataSet
+    attr_reader :examples
+
+    def initialize
+      @examples = Array.new
+    end
+
+    def load!(labels_path, images_path)
+      @examples = DataStream.new(labels_path, images_path).each.to_a
+      self
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  def print_example(ex)
+    puts(ex.label)
+    puts(ex.to_ascii)
+  end
+
+  data = MNist::DataStream.new(MNist::TRAIN_LABELS_PATH, MNist::TRAIN_IMAGES_PATH)
+  i = 0
+  data.each.
+    group_by(&:label).
+    collect { |label, values| [ label, values.first ] }.
+    sort_by(&:first).
+    first(10).
+    each do |(label, e)|
+    puts(i)
+    print_example(e)
+    i += 1
+    break if i > 20
+  end
+
+  rot = MNist::DataStream::Rotator.new(data.each, 10, Math::PI, false)
+  rot.drop(10).first(10).each do |example|
+    print_example(example)
+  end
+
+  puts("#{data.size} total #{data.width}x#{data.height} images")
+end