k_means 0.0.2

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 reddavis
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,50 @@
+= KMeans
+
+Attempting to build a fast, memory efficient K-Means program.
+
+== Install
+
+  gem sources -a http://gems.github.com
+  sudo gem install reddavis-k_means
+
+== How To Use
+  require 'rubygems'
+  require 'k_means'
+  
+  data = [[1,1], [1,2], [1,1], [1000, 1000], [500, 500]]
+  kmeans = KMeans.new(@data, :centroids => 2)
+  kmeans.inspect  # Use kmeans.view to get hold of the un-inspected array
+  => [[3, 4], [0, 1, 2]]
+  
+== Benchmarks
+
+  # 1000 records with 50 dimensions
+  data = Array.new(1000) {Array.new(50) {rand(10)}} 
+  ai4r_data = Ai4r::Data::DataSet.new(:data_items=> data)
+
+  # Clustering can happen in magical ways
+  # so lets do it over multiple times
+  n = 5
+
+  Benchmark.bm do |x|
+    x.report('KMeans') do
+      n.times { KMeans.new(data) }
+    end
+    x.report("Ai4R") do
+      n.times do
+        b = Ai4r::Clusterers::KMeans.new
+        b.build(ai4r_data, 4)
+      end
+    end
+  end
+           user     system      total        real
+  KMeans 15.960000   0.030000  15.990000 ( 16.062639)
+  Ai4R   70.230000   0.180000  70.410000 ( 70.704843)
+
+== Thanks
+
+* David Richards - For his code reviews and all round helpfulness. - http://github.com/davidrichards
+
+== Copyright
+
+Copyright (c) 2009 Red Davis. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "k_means"
+    gem.summary = %Q{K Means algorithm}
+    gem.description = %Q{Attempting to create a fast, memory efficient KMeans}
+    gem.email = "reddavis@gmail.com"
+    gem.homepage = "http://github.com/reddavis/k_means"
+    gem.authors = ["reddavis"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "k_means #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/benchmark/benchmark_ai4r.rb

@@ -0,0 +1,27 @@
+require 'benchmark'
+require 'rubygems'
+require 'benchmarker'
+require 'ai4r'
+require File.dirname(__FILE__) + '/../lib/k_means'
+
+data = Array.new(500) {Array.new(50) {rand(10)}}
+
+ai4r_data = Ai4r::Data::DataSet.new(:data_items=> data)
+
+# Clustering can happen in magical ways
+# so lets do it over multiple times
+n = 2
+
+Benchmarker.go('lib') do
+  Benchmark.bm do |x|
+    x.report('Mine') do
+      n.times { KMeans.new(data) }
+    end
+#    x.report("Ai4R") do
+#      n.times do
+        #b = Ai4r::Clusterers::KMeans.new
+        #b.build(ai4r_data, 4)
+#      end
+#    end
+  end
+end

data/k_means.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{k_means}
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["reddavis"]
+  s.date = %q{2009-11-25}
+  s.description = %q{Attempting to create a fast, memory efficient KMeans}
+  s.email = %q{reddavis@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "benchmark/benchmark_ai4r.rb",
+     "k_means.gemspec",
+     "lib/centroid.rb",
+     "lib/ext/enumerable.rb",
+     "lib/ext/object.rb",
+     "lib/k_means.rb",
+     "lib/node.rb",
+     "profiling/profile.rb",
+     "test/ext/test_enumerable.rb",
+     "test/ext/test_object.rb",
+     "test/helper.rb",
+     "test/test_centroid.rb",
+     "test/test_k_means.rb",
+     "test/test_node.rb"
+  ]
+  s.homepage = %q{http://github.com/reddavis/k_means}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{K Means algorithm}
+  s.test_files = [
+    "test/ext/test_enumerable.rb",
+     "test/ext/test_object.rb",
+     "test/helper.rb",
+     "test/test_centroid.rb",
+     "test/test_k_means.rb",
+     "test/test_node.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/centroid.rb

@@ -0,0 +1,49 @@
+class Centroid
+  
+  class << self
+    def create_centroids(amount, nodes)
+      ranges = create_ranges(nodes, nodes[0].position.size)
+      (1..amount).map do
+        position = ranges.inject([]) do |array, range|
+          array << rand_between(range[0], range[1])
+        end
+        new(position)
+      end
+    end
+    
+    private
+    
+    def create_ranges(nodes, dimensions)
+      ranges = Array.new(dimensions) {[0.0, 0.0]}
+      nodes.each do |node|
+        node.position.each_with_index do |position, index|
+          # Bottom range
+          ranges[index][0] = position if position < ranges[index][0]
+          # Top range
+          ranges[index][1] = position if position > ranges[index][1]
+        end
+      end
+      ranges
+    end
+  end
+  
+  attr_accessor :position
+  
+  def initialize(position)
+    @position = position
+  end
+  
+  # Finds the average distance of all the nodes assigned to
+  # the centroid and then moves the centroid to that position
+  def reposition(nodes)
+    return if nodes.empty?
+    averages = [0.0] * nodes[0].position.size
+    nodes.each do |node|
+      node.position.each_with_index do |position, index|
+        averages[index] += position
+      end
+    end
+    @position = averages.map {|x| x / nodes.size}
+  end
+  
+end

data/lib/ext/enumerable.rb

@@ -0,0 +1,10 @@
+module Enumerable      
+  def euclidean_distance(other)
+    sum = 0.0
+    self.each_index do |i|
+      sum += (self[i] - other[i])**2
+    end
+    Math.sqrt(sum)
+  end
+end
+

data/lib/ext/object.rb

@@ -0,0 +1,16 @@
+class Object
+  
+  # Simpler way to handle a random number between to values
+  def rand_between(a, b)
+    return rand_in_floats(a, b) if a.is_a?(Float) or b.is_a?(Float)
+    range = (a - b).abs + 1
+    rand(range) + [a,b].min
+  end
+  
+  # Handles non-integers
+  def rand_in_floats(a, b)
+    range = (a - b).abs
+    (rand * range) + [a,b].min
+  end
+  
+end

data/lib/k_means.rb

@@ -0,0 +1,78 @@
+$: << File.dirname(__FILE__)
+require 'centroid'
+require 'node'
+require 'ext/enumerable'
+require 'ext/object'
+
+class KMeans
+  
+  attr_reader :centroids, :nodes
+  
+  def initialize(data, options={})
+    k = options[:centroids] || 4
+    @verbose = options[:verbose] == true ? true : nil
+        
+    @nodes = Node.create_nodes(data)
+    @centroids = Centroid.create_centroids(k, @nodes)
+    
+    perform_cluster_process
+  end
+  
+  def inspect
+    @centroid_pockets.inspect
+  end
+  
+  def view
+    @centroid_pockets
+  end
+  
+  private
+  
+  def perform_cluster_process
+    iterations, updates = 0, 1
+    while updates > 0 && iterations < 100 
+      iterations += 1
+      verbose_message("Iteration #{iterations}")
+      updates = 0  
+      updates += update_nodes
+      reposition_centroids
+    end
+    place_nodes_into_pockets
+  end
+  
+  # This creates an array of arrays
+  # Each internal array represents a centroid
+  # and each in the array represents the nodes index
+  def place_nodes_into_pockets
+    centroid_pockets = Array.new(@centroids.size) {[]}
+    @centroids.each_with_index do |centroid, centroid_index|
+      @nodes.each_with_index do |node, node_index|
+        if node.closest_centroid == centroid
+          centroid_pockets[centroid_index] << node_index
+        end
+      end
+    end
+    @centroid_pockets = centroid_pockets
+  end
+    
+  def update_nodes
+    sum = 0
+    @nodes.each do |node|
+      sum += node.update_closest_centroid(@centroids)
+    end
+    sum
+  end
+  
+  def reposition_centroids
+    @centroids.each do |centroid|
+      nodes = [] 
+      @nodes.each {|n| nodes << n if n.closest_centroid == centroid}
+      centroid.reposition(nodes)
+    end
+  end
+        
+  def verbose_message(message)
+    puts message if @verbose
+  end
+      
+end

data/lib/node.rb

@@ -0,0 +1,44 @@
+class Node
+  
+  class << self
+    def create_nodes(data)
+      nodes = []
+      data.each do |position|
+        nodes << new(position)
+      end
+      nodes
+    end
+  end
+  
+  attr_accessor :position, :best_distance, :closest_centroid
+  
+  def initialize(position)
+    @position = position
+  end
+  
+  def update_closest_centroid(centroids)
+    calculate_initial_centroid(centroids.first) unless @closest_centroid
+    updated = false
+    centroids.each do |centroid|
+      distance = calculate_distance(centroid)
+      if distance < best_distance
+        updated = true
+        @closest_centroid = centroid
+        @best_distance = distance
+      end
+    end
+    updated == true ? 1 : 0
+  end
+    
+  private
+  
+  def calculate_initial_centroid(centroid)
+    @closest_centroid = centroid
+    @best_distance = calculate_distance(centroid)
+  end
+  
+  def calculate_distance(centroid)
+    @position.euclidean_distance(centroid.position)
+  end
+  
+end

data/profiling/profile.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../lib/k_means'
+require 'rubygems'
+require 'ruby-prof'
+
+data = Array.new(100) {Array.new(2) {rand}}
+
+result = RubyProf.profile do
+  a = KMeans.new(data)
+end
+
+printer = RubyProf::FlatPrinter.new(result)
+printer.print(STDOUT, 0)

data/test/ext/test_enumerable.rb

@@ -0,0 +1,11 @@
+require 'helper'
+
+class TestEnumerable < Test::Unit::TestCase
+  context "Euclidean Distance" do
+    
+    should "return 5" do
+      assert_equal 5, [10].euclidean_distance([5])
+    end
+    
+  end
+end

data/test/ext/test_object.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+class TestObject < Test::Unit::TestCase
+  context "Random Number Between" do
+    
+    should "return a number between 10 and 20" do
+      n = rand_between(10, 20)
+      assert_between(10..20, n)
+    end
+    
+    should "return a float between 10.0 and 10.9" do
+      n = rand_between(10.0, 10.9)
+      assert_between(10..11, n)
+      assert_kind_of Float, n
+    end
+    
+  end
+end

data/test/helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'k_means'
+
+class Test::Unit::TestCase
+  def assert_between(range, n)
+    assert range === n
+  end
+end

data/test/test_centroid.rb

@@ -0,0 +1,45 @@
+require 'helper'
+
+class TestCentroid < Test::Unit::TestCase
+  context "A Centroid" do
+    
+    setup do
+      @centroid = Centroid.new([1, 2, 3])
+    end
+    
+    should "return an array" do
+      assert_kind_of Array, @centroid.position
+    end
+    
+    should "return an array of centroids" do
+      centroids = Centroid.create_centroids(4, create_nodes)
+      assert_kind_of Array, centroids
+      assert_kind_of Centroid, centroids.first
+    end
+    
+    should "create 4 centroids" do
+      centroids = Centroid.create_centroids(4, create_nodes)
+      assert_equal 4, centroids.size
+    end
+    
+    should "reposition nodes" do
+      nodes = create_nodes
+      average_position = [0.0] * nodes[0].position.size
+      nodes.each do |node|
+        node.position.each_with_index do |position, index|
+          average_position[index] += position
+        end
+      end
+      average_position.map! {|x| x / 2}
+      @centroid.reposition(create_nodes)
+      assert_equal average_position, @centroid.position
+    end
+      
+  end
+  
+  private
+  
+  def create_nodes
+    Node.create_nodes([[1,2,3], [4,5,6]])
+  end
+end

data/test/test_k_means.rb

@@ -0,0 +1,24 @@
+require 'helper'
+
+class TestKMeans < Test::Unit::TestCase
+  context "A KMeans Instance" do
+    
+    setup do
+      @data = Array.new(200) {Array.new(2) {rand}}
+      @kmeans = KMeans.new(@data, :centroids => 2)
+    end
+  
+    should "return an array" do
+      assert_kind_of String, @kmeans.inspect
+    end
+    
+    should "have 2 centroids" do
+      assert_equal 2, @kmeans.centroids.size
+    end
+    
+    should "have 200 nodes" do
+      assert_equal 200, @kmeans.nodes.size
+    end
+        
+  end
+end

data/test/test_node.rb

@@ -0,0 +1,43 @@
+require 'helper'
+
+class TestNode < Test::Unit::TestCase
+  context "A Data Instance" do
+    
+    setup do
+      @node = Node.new([4, 4])
+    end
+  
+    should "return an array" do
+      assert_kind_of Array, @node.position
+    end
+    
+    should "create an array of nodes" do
+      data = Array.new(10) {Array.new(2) {rand}}
+      nodes = Node.create_nodes(data)
+      assert_kind_of Array, nodes
+    end
+    
+    should "create 10 nodes" do
+      data = Array.new(10) {Array.new(2) {rand}}
+      nodes = Node.create_nodes(data)
+      assert_equal 10, nodes.size
+    end
+    
+    should "initialize closest centroid" do
+      a = @node.closest_centroid
+      centroids = [Centroid.new([4, 4]), Centroid.new([5, 4])]
+      @node.update_closest_centroid(centroids)
+      assert_not_equal nil, @node.closest_centroid
+    end
+    
+    should "update closest centroid" do
+      centroids = [Centroid.new([5, 4])]
+      @node.update_closest_centroid(centroids)
+      a = @node.closest_centroid
+      @node.update_closest_centroid([Centroid.new([4,4])])
+      assert_not_equal a, @node.closest_centroid
+      assert_equal 0, @node.best_distance
+    end
+        
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: k_means
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- reddavis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-25 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: Attempting to create a fast, memory efficient KMeans
+email: reddavis@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- benchmark/benchmark_ai4r.rb
+- k_means.gemspec
+- lib/centroid.rb
+- lib/ext/enumerable.rb
+- lib/ext/object.rb
+- lib/k_means.rb
+- lib/node.rb
+- profiling/profile.rb
+- test/ext/test_enumerable.rb
+- test/ext/test_object.rb
+- test/helper.rb
+- test/test_centroid.rb
+- test/test_k_means.rb
+- test/test_node.rb
+has_rdoc: true
+homepage: http://github.com/reddavis/k_means
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: K Means algorithm
+test_files: 
+- test/ext/test_enumerable.rb
+- test/ext/test_object.rb
+- test/helper.rb
+- test/test_centroid.rb
+- test/test_k_means.rb
+- test/test_node.rb