cluda 0.0.1 → 0.0.2

data/lib/cluda/cluda_common.rb

@@ -0,0 +1,79 @@
+module Cluda
+  class InvalidPoint < RuntimeError; end
+  class InvalidCentroid < RuntimeError; end
+  class InvalidSmartPoint < RuntimeError; end
+  class InvalidDistanceMethod < RuntimeError; end
+  
+  # For an output given by CluDA calculate the means for each centroid
+  #
+  #Example:
+  #  > clusters = {{:x=>2, :y=>2}=>
+  #                           [{:x=>1, :y=>1, :distance=>1.4142135623730951},
+  #                            {:x=>2, :y=>1, :distance=>1.0},
+  #                            {:x=>1, :y=>2, :distance=>1.0},
+  #                            {:x=>2, :y=>2, :distance=>0.0}]}
+  #  > Cluda.median_for_centroids(clusters)
+  #Arguments:
+  #   points:            ( Hash )
+  def self.median_for_centroids ( points )
+    points.keys.each do | centroid |
+      validate_smart_points(  points[centroid] )
+    end
+
+    points.keys.map do |centroid|
+      centroid.merge( median: median_for_centroid( centroid, points ) )
+    end
+  end
+  
+  protected
+  
+  def self.valid_class?( name )
+    ['euclidean', 'chebyshev', 'manhattan'].include?( name.downcase )
+  end
+
+  def self.validate_centroids( centroids )
+    centroids = centroids.is_a?(Array) ? centroids : [ centroids ]  
+    
+    validate(centroids)
+   
+    centroids.each do |point|
+      raise InvalidCentroid unless  point.include?(:median)
+    end
+
+    centroids
+  end
+  
+  def self.validate_smart_points( points )
+    points = points.is_a?(Array) ? points : [ points ]  
+    
+    validate( points )
+   
+    points.each do |point|
+      raise InvalidSmartPoint unless  point.include?(:distance)
+    end
+
+    points
+  end
+  
+  def self.validate( data )
+    points = data.is_a?(Array) ? data : [ data ]  
+    points.each do |point|
+      raise InvalidPoint unless  point.is_a?(Hash) &&  
+                                 point.include?(:x) && point.include?(:y) &&
+                                 point[:x].is_a?(Numeric) && point[:y].is_a?(Numeric)
+    end
+
+    points 
+  end
+
+  def self.median_for_centroid( centroid, points )
+    median( points[centroid].map{ |point| point[:distance] } )
+  end
+
+  def self.median( list )
+    sorted_list = list.sort
+    len = list.size
+
+    sorted_list[( (len / 2 ) + 0.5 ).floor]
+  end
+end

data/lib/cluda/distances/chebyshev.rb

@@ -2,7 +2,7 @@ module Cluda
   class Chebyshev <  Distance
     
     def self.distance(x0, x)
-      validate( [x0,x] )
+      Cluda.validate( [x0,x] )
 
       [ (x0[:x] - x[:x]).abs, (x0[:y] - x[:y]).abs ].max
     end

data/lib/cluda/distances/distance.rb

@@ -1,24 +1,9 @@
 module Cluda
-  class InvalidPoint < RuntimeError; end
-  
   class Distance 
     extend Math
     
     def self.distance(x0, x)
       raise ::NotImplementedError.new("You must implement distance method")
     end
-
-    protected
-
-    def self.validate( data )
-      points = data.is_a?(Array) ? data : [ data ]  
-      points.each do |point|
-        raise InvalidPoint unless  point.is_a?(Hash) &&  
-                                   point.include?(:x) && point.include?(:y) &&
-                                   point[:x].is_a?(Numeric) && point[:y].is_a?(Numeric)
-      end
-
-      points 
-    end
   end
 end

data/lib/cluda/distances/euclidean.rb

@@ -2,7 +2,7 @@ module Cluda
   class Euclidean <  Distance
     
     def self.distance(x0, x)
-      validate( [x0,x] )
+      Cluda.validate( [x0,x] )
 
       sqrt( (x0[:x] - x[:x]) ** 2 + (x0[:y] - x[:y]) ** 2 )
     end

data/lib/cluda/distances/manhattan.rb

@@ -2,7 +2,7 @@ module Cluda
   class Manhattan <  Distance
     
     def self.distance(x0, x)
-      validate( [x0,x] )
+      Cluda.validate( [x0,x] )
 
       (x0[:x] - x[:x]).abs + (x0[:y] - x[:y]).abs
     end

data/lib/cluda/kmeans.rb

@@ -3,24 +3,61 @@ require 'cluda/distances/euclidean'
 require 'cluda/distances/chebyshev'
 
 module Cluda
-  class InvalidDistanceMethod < RuntimeError; end
-
   class Kmeans
-    def self.classify( list, k, class_name = 'euclidean', max_iterations = 50 )
-      raise InvalidDistanceMethod unless valid_class?(class_name)
+
+    DEFAULT_OPTS = { k: 1, 
+                     centroids: nil, 
+                     distance_method: 'euclidean', 
+                     be_smart: false,
+                     margin_distance_percentage: 0,
+                     max_iterations: 50 }
+
+    #Classify the points using KMeans as the clustering algorithm
+    #
+    #Example:
+    #   >> points = [ { x: 1, y: 1}, { x: 2, y: 1}, { x: 1, y: 2}, { x: 2, y: 2}, { x: 4, y: 6}, { x: 5, y: 7}, { x: 5, y: 6}, { x: 5, y: 5}, { x: 6, y: 6}, { x: 6, y: 5}]
+    #   >> Cluda::Kmeans.classify( points, k: 1, distance_method: 'euclidean', be_smart: true, max_iterations: 50)
+    #Arguments:
+    #   list:                       (Array [Hash] )
+    #   k:                          (Numeric) *optional*
+    #   centroids:                  (Array) *optional*
+    #   distance_method:            (String) *optional*
+    #   be_smart:                   (Boolean) *optional* [If you want CluDA to be smart you have to specify the centroids ]
+    #   margin_distance_percentage: (Numeric) *optional* [Between 0 and 1]
+    #   max_iterations:             (Numeric) *optional*
+    def self.classify( list, opts = {} )
+      @opts = DEFAULT_OPTS.merge(opts)
+      
+      raise Cluda::InvalidDistanceMethod unless Cluda::valid_class?(@opts[:distance_method])
+     
+      _class = Cluda.const_get( @opts[:distance_method].downcase.capitalize )
       
-      _class = Cluda.const_get( class_name.downcase.capitalize )
-      _class.validate( list )
+      Cluda.validate( list ) 
+      Cluda.validate_centroids( @opts[:centroids] ) if @opts[:be_smart] 
 
       iter = 1
-      previous_centroids = nil
-      centroids = initialize_centroids( list , k, _class )
+      max_iterations             = @opts[:max_iterations]
+      centroids                  = @opts[:centroids].nil? || @opts[:centroids].empty? ? initialize_centroids( list , @opts[:k]) : process_centroids( @opts[:centroids] )
+      previous_centroids         = nil
+      smart_clustering           = @opts[:be_smart]
+      margin_distance_percentage = @opts[:margin_distance_percentage]
 
       while (iter < max_iterations) && (previous_centroids != centroids)
         output = init_output(centroids)
-        
+        margin = smart_clustering ? @median_centroid * margin_distance_percentage : 0
+
         list.each do |point|
-          output[nearest_centroid(point, centroids, _class)] << point
+          centroid, distance = nearest_centroid(point, centroids, _class)
+          
+          if smart_clustering && distance > ( @median_centroid + margin )
+            @median_centroid = distance
+            centroids << point
+            create_centroid(point, output)
+            centroid = point
+            distance = 0
+          end
+
+          output[centroid] << point.merge( distance: distance )
         end
 
         iter += 1
@@ -36,7 +73,7 @@ module Cluda
     def self.nearest_centroid(point, centroids, _class = Cluda::Euclidean )
       return nil if centroids.empty?
       
-      _class.validate( point )
+      Cluda.validate( point )
       
       nearest_centroid = centroids[0]
       min_distance = _class.distance(point, nearest_centroid)
@@ -49,11 +86,11 @@ module Cluda
         end
       end
 
-      nearest_centroid
+      [nearest_centroid, min_distance]
     end
 
-    def self.initialize_centroids( list , k, _class = Cluda::Euclidean )
-      _class.validate( list )
+    def self.initialize_centroids( list , k )
+      Cluda.validate( list )
 
       return [] if list.empty? || k > list.size
 
@@ -62,21 +99,22 @@ module Cluda
 
     private 
 
-    def self.valid_class?( name )
-      ['euclidean', 'chebyshev', 'manhattan'].include?( name.downcase )
-    end
-
     def self.init_output(centroids) 
       centroids.each_with_object({}) do |centroid, memo|
         memo[centroid] = []
       end
     end
 
-    def self.median( list )
-      sorted_list = list.sort
-      len = list.size
+    def self.create_centroid( centroid, output )
+      output[centroid] = []
+    end
 
-      sorted_list[( (len / 2 ) + 0.5 ).floor]
+    def self.process_centroids(centroids)
+      centroids.each_with_object([]) do |point, memo|
+        @median_centroid = point[:median] if @median_centroid.nil?  || @median_centroid < point[:median]
+          
+        memo << { x: point[:x], y: point[:y] }
+      end
     end
 
     def self.get_key_values( points, key )
@@ -85,11 +123,13 @@ module Cluda
     
     def self.move_centroids( output )
       output.map do |(key, value)|
-        x = median( get_key_values(value, :x) )
-        y = median( get_key_values(value, :y) )
+        unless value.empty?
+          x = Cluda.median( get_key_values(value, :x) )
+          y = Cluda.median( get_key_values(value, :y) )
         
-        { x: x, y: y }
-      end
+          { x: x, y: y }
+        end
+      end.compact
     end
   end
 end

data/lib/cluda.rb

@@ -1,4 +1,5 @@
 $:.unshift File.expand_path('..', __FILE__ )
 
 require 'cluda/distances/distance'
+require 'cluda/cluda_common'
 require 'cluda/kmeans' 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cluda
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-29 00:00:00.000000000 Z
+date: 2014-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -50,6 +50,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/cluda.rb
+- lib/cluda/cluda_common.rb
 - lib/cluda/kmeans.rb
 - lib/cluda/distances/distance.rb
 - lib/cluda/distances/euclidean.rb