buncher 0.0.2 → 1.0.0

data/Manifest.txt

@@ -3,6 +3,6 @@ History.txt
 Manifest.txt
 README.txt
 Rakefile
-bin/buncher
+lib/buncher/buncher.bundle
 lib/buncher.rb
 test/test_buncher.rb

data/Rakefile

@@ -4,6 +4,7 @@ require "rubygems"
 require "hoe"
 
 Hoe.plugin :git
+Hoe.plugin :debugging # for gdb
 Hoe.plugin :compiler
 # Hoe.plugin :gem_prelude_sucks
 # Hoe.plugin :inline
@@ -13,7 +14,7 @@ Hoe.plugin :minitest
 # Hoe.plugin :rdoc
 
 Hoe.spec "buncher" do
-  developer("Robert Mathews", "rob@justsoftwareconsulting.com")
+  developer("Robert Mathews", "rob@drync.com")
   self.extra_dev_deps
 
   license "MIT" # this should match the license in the README

data/ext/buncher/extconf.rb

@@ -6,6 +6,7 @@ extension_name = 'buncher'
 
 # The destination
 dir_config(extension_name)
-
+# add some standard template libraries (headers only)
+dir_config('boost','ext/boost/1.57.0')
 # Do the work
 create_makefile(extension_name)

data/lib/buncher.rb

@@ -1,7 +1,6 @@
 require 'buncher/buncher'
-require 'array'
 module Buncher
-  VERSION = "0.0.2"
+  VERSION = "1.0.0"
   # your cluster needs to look like this. Make a bunch of them and pass them in. It's ok to pass in empty elements to start.
   class Cluster
     attr_accessor :elements
@@ -11,49 +10,15 @@ module Buncher
       self.elements = elements
     end
 
-    def ndim
-      2
-    end
-
     def clear
       elements.clear
     end
 
-    def sum
-      raise "calculate the sum of the elements"
-    end
-
-    def calculate_center
-      raise "calculate the center as an average of the elements"
-    end
-    def distance_squared(element)
-      raise "Distance between center and element - Implemented in a subclass"
-    end
-
-    def distortion
-      elements.inject(0) {|acc, ele| distance_squared(ele)}
-    end
-
-    # return the distance to the closest element and remove the element from the list
-    def closest!(elements)
-      min_distance=nil
-      min_index=nil
-      elements.each_with_index do |element, index|
-        distance = distance_squared(element)
-        if(min_distance.nil? || min_distance > distance)
-          min_distance = distance
-          min_index = index
-        end
-      end
-      elements.delete_at(min_index)
-      min_distance
+    def size
+      elements.size
     end
 
-
-    # some useful math
-    def cdf(z)
-      (0.5 * (1.0 + Math.erf((z*1.0)/1.4142135623730951)))
-    end
+    # distortion - C++ code
   end
 
   # split array into several equal sized parts
@@ -73,101 +38,9 @@ module Buncher
     groups
   end
 
-  def self.distance(old_centers, new_clusters)
-    new_clusters.inject(0) {|acc, cluster| acc + cluster.closest!(old_centers)}
-  end
-
-  def self.run(centers, elements, nb_jobs)
-    old_centers=nil
-    count=0
-    while(true) do
-      # clear the centers first
-      centers.map(&:clear)
-
-      # create jobs
-      jobs = []
-      elements_for_jobs = split_array_into_parts(elements, nb_jobs)
-      nb_jobs.times do |i|
-        jobs << Job.new(centers, elements_for_jobs[i])
-      end
-
-      if(nb_jobs > 1)
-        # run jobs in parallel
-        queue = Cabiri::JobQueue.new
-        nb_jobs.times do |i|
-          queue.add(i) { jobs[i].run }
-        end
-        queue.start(nb_jobs)
-      else
-        jobs.map(&:run)
-      end
-      centers.map(&:calculate_center)
-      distance = distance(old_centers,centers) if old_centers
-      # puts "iteration #{count+=1}: distance #{distance}" if old_centers
-      break if old_centers && distance < 0.0001
-      old_centers=centers.map(&:center)
-    end
-    centers
-  end
-
-  # job that will be used for parallelization with Cabiri
-  class Job
-    attr_accessor :centers
-    attr_accessor :elements
-
-    def initialize(centers, elements)
-      @centers = centers
-      @elements = elements
-    end
-
-    def run
-      assignElementsToClosestCenter  # this is center, with list of elements
-      @centers
-    end
-
-    def assignElementsToClosestCenter
-      @elements.each do |element|
-        best_center = nil
-        best_distance = nil
-
-        @centers.each do |center|
-          distance = center.distance_squared(element)
-          if best_distance.nil? or distance < best_distance
-            best_center = center
-            best_distance = distance
-          end
-        end
-        best_center.elements << element
-      end
-    end
-  end
-
-  # from the kmeans++ algorithm for choosing centers. returns a list of centers
-  def self.choose_centers(cluster_clazz, elements, number_centers)
-    ele = elements.sample(1).first
-    elements = elements.dup
-    centers = [cluster_clazz.new(ele)]
-    # puts "center 1 is #{centers.first.center}"
-    elements.delete(ele)
-    (2..number_centers).each do |index|
-      probability_distribution=[]
-      sum=elements.inject(0) {|sum, ele| distance=centers.inject(Float::MAX) {|acc,center|[center.distance_squared(ele),acc].min};sum+=distance;probability_distribution <<[distance,ele];sum}
-      dice = rand(0..sum)
-      # puts "dice=#{dice}, sum=#{sum}"
-      # puts "distribution"
-      # probability_distribution.each {|key,val| puts "#{key} : #{val}"}
-      # puts
-      ignore, next_center = probability_distribution.detect {|prob,ele|dice-=prob; dice <=0}
-      # puts "center #{index} is #{next_center}"
-      centers.unshift(cluster_clazz.new(next_center))
-      elements.delete_at(elements.index(next_center))
-    end
-    centers
-  end
-
   def self.calc_aK(centers, last_aK)
     if(centers.size == 2)
-       1.0-3.0/(4.0*centers.first.ndim)
+       1.0-3.0/(4.0*centers.first.center.size)
     else
       last_aK + (1.0 - last_aK) / 6
     end
@@ -187,7 +60,7 @@ module Buncher
 
   # run the clustering algorithm until have calculated the current number of clusters, taken from this paper:
   # http://papers.nips.cc/paper/2526-learning-the-k-in-k-means.pdf
-  def self.cluster(start,cluster_clazz,elements,threads=1)
+  def self.cluster(elements)
     changed=true
     round=0
     solutions={}
@@ -195,16 +68,17 @@ module Buncher
     # that.
     not_clustered = last_sK = last_aK =last_fK=nil
     max_clusters=[1,elements.size/4].max
-    (start..max_clusters).each do |number_clusters|
-      initial_centers = choose_centers(cluster_clazz, elements, number_clusters)
+    (1..max_clusters).each do |number_clusters|
+      initial_centers = choose_centers(elements, number_clusters) # C++ Native code
       centers = initial_centers.map(&:dup)
-      centers = run(centers,elements,threads)
+      centers = kmeans(centers,elements) ## C++ Native code
       yield(elements, centers, initial_centers) if block_given?
       not_clustered ||=centers
       last_fK, last_sK, last_aK = fK(centers,last_sK, last_aK)
-      puts "#{number_clusters}: fK() = #{last_fK}, last_sK=#{last_sK} last_aK=#{last_aK} "
+      puts "summary #{number_clusters}: fK() = #{last_fK}, last_sK=#{last_sK} last_aK=#{last_aK} "
+      puts
       solutions[last_fK]=centers
-      # break if number_clusters == 3 ## debugging
+      # break if number_clusters == 2 ## debugging
     end
     min_fK =solutions.keys.sort.first
     if min_fK > 0.85

data/test/test_buncher.rb

@@ -1,9 +1,121 @@
-gem "minitest"
-require "minitest/autorun"
 require "buncher"
+require 'rubystats'
+require 'gnuplot'
+
+def dump(centers)
+  puts "centers are"
+  centers.each {|ccc| puts "center #{ccc.center.inspect} #{ccc.elements[0]}, #{ccc.elements[1]}"}
+end
+
+def init_data(number_points, number_clusters)
+  points_per_cluster = number_points.to_f / number_clusters
+  elements=[]
+  extra=0
+  index=0
+  seed=[[0,1],[0,0],[1,0]]
+  number_clusters.times do
+    # gens = [Rubystats::NormalDistribution.new(rand(0..1), 0.05), Rubystats::NormalDistribution.new(rand(0..1), 0.05)]
+    gens = [Rubystats::NormalDistribution.new(seed[index][0], 0.05), Rubystats::NormalDistribution.new(seed[index][1], 0.05)]
+    index+=1
+    extra+= points_per_cluster - points_per_cluster.floor
+    points = gens.map {|gen|gen.rng(points_per_cluster.floor+extra.floor)}
+    points.first.each_index {|iii|elements << [points[0][iii],points[1][iii]]}
+    extra-=1.0 if(extra > 1)
+  end
+  elements
+end
+
+def plot(file_name,points,centers, initial_centers=nil)
+  Gnuplot.open do |gp|
+    Gnuplot::Plot.new( gp ) do |plot|
+    
+      plot.title  "Cluster Plot (#{centers.size})"
+      plot.xlabel "x"
+      plot.ylabel "y"
+      plot.terminal "gif"
+      plot.output file_name
+        
+      x = points.map(&:first)
+      y = points.map(&:last)
+
+      plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+        ds.with = "points"
+        ds.notitle
+      end
+
+      unless initial_centers.nil?
+        x = initial_centers.map(&:center).map(&:first)
+        y = initial_centers.map(&:center).map(&:last)
+        plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+          ds.with = "points"
+          ds.title="initial centers"
+        end
+      end
+
+      x = centers.map(&:center).map(&:first)
+      y = centers.map(&:center).map(&:last)
+      plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+        ds.with = "points"
+        ds.title="centers"
+      end
+    end
+  end
+  file_name
+end
 
 class TestBuncher < Minitest::Test
-  def test_sanity
-    assert_equal 'hello world', Buncher.hello_world
+WORKING=<<-'EOS'
+  def test_should_find_the_one_center
+      elements = [[1,1]]
+      starting_centers = elements.sample(1).map {|aaa| Buncher::Cluster.new(aaa)}
+      new_centers = Buncher::kmeans(starting_centers, elements)
+      dump(new_centers)
+      assert_in_delta(new_centers.first.center[0],1.0,0.01)
+      assert_in_delta(new_centers.first.center[1],1.0,0.01)
+  end
+
+  def test_choose_centers_wrapper
+      elements = [[1,1]]
+      new_centers = Buncher::choose_centers(elements, 1)
+      dump(new_centers)
+      assert_in_delta(new_centers.first.center[1],1.0,0.01)
+      assert_in_delta(new_centers.first.center[1],1.0,0.01)
+  end
+  def test_choose_centers_wrapper2
+      elements = init_data(100,3)
+      new_centers = Buncher::choose_centers(elements, 3)
+      dump(new_centers)
+      assert_equal(new_centers.size,3)
+  end
+  def test_should_find_one_cluster
+      elements = [[1,1]]
+      new_centers = Buncher::cluster(elements)
+      dump(new_centers)
+      assert_equal(new_centers.size,1)
+  end
+  def test_choose_centers_wrapper2
+      elements = init_data(100,3)
+      new_centers = Buncher::choose_centers(elements, 3)
+      plot("/tmp/kmeans_initial_#{new_centers.size}.png",elements, new_centers)
+      dump(new_centers)
+      `open /tmp/kmeans_initial_#{new_centers.size}.png`
+      assert_equal(new_centers.size,3)
+  end
+EOS
+
+  def test_gaussian_distribution_of_100_points_in_3_clusters
+    12.times do |run|
+      # srand(843284148793854177950180651080082381)
+      elements = init_data(100,3)
+      # elements.each {|eee| puts "#{eee[0]},#{eee[1]}"}
+      # new_centers = Buncher::cluster(elements) {|elements,centers, initial_centers| puts "run #{run} setup";plot("/tmp/#{run}_centers_#{centers.size}.png",elements,initial_centers)}
+      new_centers = Buncher::cluster(elements) {|elements,centers, initial_centers| 
+        plot("/tmp/#{run}_centers_#{centers.size}.png",elements,centers, initial_centers)
+      }
+      puts "run #{run}: k is #{new_centers.size}, seed was #{srand}"
+      puts "ERROR "*4 if new_centers.size != 3
+      puts
+      assert_equal(3,new_centers.size)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: buncher
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-19 00:00:00.000000000 Z
+date: 2015-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '5.4'
+        version: '5.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '5.4'
+        version: '5.6'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -82,7 +82,7 @@ description: ! 'buncher implements a variant of the popular k-means clustering a
 
   in order to find the best value of K.'
 email:
-- rob@justsoftwareconsulting.com
+- rob@drync.com
 executables: []
 extensions:
 - ext/buncher/extconf.rb
@@ -96,6 +96,7 @@ files:
 - Manifest.txt
 - README.txt
 - Rakefile
+- lib/buncher/buncher.bundle
 - lib/buncher.rb
 - test/test_buncher.rb
 - ext/buncher/extconf.rb