ai4r 1.7 → 1.8

data/README.rdoc

@@ -36,6 +36,11 @@ If you do not want to make it public, send it to me: Sergio Fierens, email addre
 AI4R is an active project. If you are interested about what we are working on, 
 checkout the development roadmap: http://wiki.jadeferret.com/AI4R_RoadMap 
 
+= Contributors
+
+* Thomas Kern (SOM implementation and examples)
+* Sergio Fierens
+
 = Disclaimer
 
 In plain english:

data/examples/som/som_data.rb

@@ -0,0 +1,156 @@
+# data is from the iris dataset (http://archive.ics.uci.edu/ml/datasets/Iris)
+# it is the full dataset, removing the last column
+# website provides additional information on the dataset itself (attributes, class distribution, etc)
+
+SOM_DATA = [
+        [5.1, 3.5, 1.4, 0.2],
+        [4.9, 3.0, 1.4, 0.2],
+        [4.7, 3.2, 1.3, 0.2],
+        [4.6, 3.1, 1.5, 0.2],
+        [5.0, 3.6, 1.4, 0.2],
+        [5.4, 3.9, 1.7, 0.4],
+        [4.6, 3.4, 1.4, 0.3],
+        [5.0, 3.4, 1.5, 0.2],
+        [4.4, 2.9, 1.4, 0.2],
+        [4.9, 3.1, 1.5, 0.1],
+        [5.4, 3.7, 1.5, 0.2],
+        [4.8, 3.4, 1.6, 0.2],
+        [4.8, 3.0, 1.4, 0.1],
+        [4.3, 3.0, 1.1, 0.1],
+        [5.8, 4.0, 1.2, 0.2],
+        [5.7, 4.4, 1.5, 0.4],
+        [5.4, 3.9, 1.3, 0.4],
+        [5.1, 3.5, 1.4, 0.3],
+        [5.7, 3.8, 1.7, 0.3],
+        [5.1, 3.8, 1.5, 0.3],
+        [5.4, 3.4, 1.7, 0.2],
+        [5.1, 3.7, 1.5, 0.4],
+        [4.6, 3.6, 1.0, 0.2],
+        [5.1, 3.3, 1.7, 0.5],
+        [4.8, 3.4, 1.9, 0.2],
+        [5.0, 3.0, 1.6, 0.2],
+        [5.0, 3.4, 1.6, 0.4],
+        [5.2, 3.5, 1.5, 0.2],
+        [5.2, 3.4, 1.4, 0.2],
+        [4.7, 3.2, 1.6, 0.2],
+        [4.8, 3.1, 1.6, 0.2],
+        [5.4, 3.4, 1.5, 0.4],
+        [5.2, 4.1, 1.5, 0.1],
+        [5.5, 4.2, 1.4, 0.2],
+        [4.9, 3.1, 1.5, 0.1],
+        [5.0, 3.2, 1.2, 0.2],
+        [5.5, 3.5, 1.3, 0.2],
+        [4.9, 3.1, 1.5, 0.1],
+        [4.4, 3.0, 1.3, 0.2],
+        [5.1, 3.4, 1.5, 0.2],
+        [5.0, 3.5, 1.3, 0.3],
+        [4.5, 2.3, 1.3, 0.3],
+        [4.4, 3.2, 1.3, 0.2],
+        [5.0, 3.5, 1.6, 0.6],
+        [5.1, 3.8, 1.9, 0.4],
+        [4.8, 3.0, 1.4, 0.3],
+        [5.1, 3.8, 1.6, 0.2],
+        [4.6, 3.2, 1.4, 0.2],
+        [5.3, 3.7, 1.5, 0.2],
+        [5.0, 3.3, 1.4, 0.2],
+        [7.0, 3.2, 4.7, 1.4],
+        [6.4, 3.2, 4.5, 1.5],
+        [6.9, 3.1, 4.9, 1.5],
+        [5.5, 2.3, 4.0, 1.3],
+        [6.5, 2.8, 4.6, 1.5],
+        [5.7, 2.8, 4.5, 1.3],
+        [6.3, 3.3, 4.7, 1.6],
+        [4.9, 2.4, 3.3, 1.0],
+        [6.6, 2.9, 4.6, 1.3],
+        [5.2, 2.7, 3.9, 1.4],
+        [5.0, 2.0, 3.5, 1.0],
+        [5.9, 3.0, 4.2, 1.5],
+        [6.0, 2.2, 4.0, 1.0],
+        [6.1, 2.9, 4.7, 1.4],
+        [5.6, 2.9, 3.6, 1.3],
+        [6.7, 3.1, 4.4, 1.4],
+        [5.6, 3.0, 4.5, 1.5],
+        [5.8, 2.7, 4.1, 1.0],
+        [6.2, 2.2, 4.5, 1.5],
+        [5.6, 2.5, 3.9, 1.1],
+        [5.9, 3.2, 4.8, 1.8],
+        [6.1, 2.8, 4.0, 1.3],
+        [6.3, 2.5, 4.9, 1.5],
+        [6.1, 2.8, 4.7, 1.2],
+        [6.4, 2.9, 4.3, 1.3],
+        [6.6, 3.0, 4.4, 1.4],
+        [6.8, 2.8, 4.8, 1.4],
+        [6.7, 3.0, 5.0, 1.7],
+        [6.0, 2.9, 4.5, 1.5],
+        [5.7, 2.6, 3.5, 1.0],
+        [5.5, 2.4, 3.8, 1.1],
+        [5.5, 2.4, 3.7, 1.0],
+        [5.8, 2.7, 3.9, 1.2],
+        [6.0, 2.7, 5.1, 1.6],
+        [5.4, 3.0, 4.5, 1.5],
+        [6.0, 3.4, 4.5, 1.6],
+        [6.7, 3.1, 4.7, 1.5],
+        [6.3, 2.3, 4.4, 1.3],
+        [5.6, 3.0, 4.1, 1.3],
+        [5.5, 2.5, 4.0, 1.3],
+        [5.5, 2.6, 4.4, 1.2],
+        [6.1, 3.0, 4.6, 1.4],
+        [5.8, 2.6, 4.0, 1.2],
+        [5.0, 2.3, 3.3, 1.0],
+        [5.6, 2.7, 4.2, 1.3],
+        [5.7, 3.0, 4.2, 1.2],
+        [5.7, 2.9, 4.2, 1.3],
+        [6.2, 2.9, 4.3, 1.3],
+        [5.1, 2.5, 3.0, 1.1],
+        [5.7, 2.8, 4.1, 1.3],
+        [6.3, 3.3, 6.0, 2.5],
+        [5.8, 2.7, 5.1, 1.9],
+        [7.1, 3.0, 5.9, 2.1],
+        [6.3, 2.9, 5.6, 1.8],
+        [6.5, 3.0, 5.8, 2.2],
+        [7.6, 3.0, 6.6, 2.1],
+        [4.9, 2.5, 4.5, 1.7],
+        [7.3, 2.9, 6.3, 1.8],
+        [6.7, 2.5, 5.8, 1.8],
+        [7.2, 3.6, 6.1, 2.5],
+        [6.5, 3.2, 5.1, 2.0],
+        [6.4, 2.7, 5.3, 1.9],
+        [6.8, 3.0, 5.5, 2.1],
+        [5.7, 2.5, 5.0, 2.0],
+        [5.8, 2.8, 5.1, 2.4],
+        [6.4, 3.2, 5.3, 2.3],
+        [6.5, 3.0, 5.5, 1.8],
+        [7.7, 3.8, 6.7, 2.2],
+        [7.7, 2.6, 6.9, 2.3],
+        [6.0, 2.2, 5.0, 1.5],
+        [6.9, 3.2, 5.7, 2.3],
+        [5.6, 2.8, 4.9, 2.0],
+        [7.7, 2.8, 6.7, 2.0],
+        [6.3, 2.7, 4.9, 1.8],
+        [6.7, 3.3, 5.7, 2.1],
+        [7.2, 3.2, 6.0, 1.8],
+        [6.2, 2.8, 4.8, 1.8],
+        [6.1, 3.0, 4.9, 1.8],
+        [6.4, 2.8, 5.6, 2.1],
+        [7.2, 3.0, 5.8, 1.6],
+        [7.4, 2.8, 6.1, 1.9],
+        [7.9, 3.8, 6.4, 2.0],
+        [6.4, 2.8, 5.6, 2.2],
+        [6.3, 2.8, 5.1, 1.5],
+        [6.1, 2.6, 5.6, 1.4],
+        [7.7, 3.0, 6.1, 2.3],
+        [6.3, 3.4, 5.6, 2.4],
+        [6.4, 3.1, 5.5, 1.8],
+        [6.0, 3.0, 4.8, 1.8],
+        [6.9, 3.1, 5.4, 2.1],
+        [6.7, 3.1, 5.6, 2.4],
+        [6.9, 3.1, 5.1, 2.3],
+        [5.8, 2.7, 5.1, 1.9],
+        [6.8, 3.2, 5.9, 2.3],
+        [6.7, 3.3, 5.7, 2.5],
+        [6.7, 3.0, 5.2, 2.3],
+        [6.3, 2.5, 5.0, 1.9],
+        [6.5, 3.0, 5.2, 2.0],
+        [6.2, 3.4, 5.4, 2.3],
+        [5.9, 3.0, 5.1, 1.8],
+]

data/examples/som/som_multi_node_example.rb

@@ -0,0 +1,22 @@
+# this example shows the impact of the size of a som on the global error distance
+require File.dirname(__FILE__) + '/../../lib/ai4r/som/som'
+require File.dirname(__FILE__) + '/som_data'
+require 'benchmark'
+
+10.times do |t|
+  t += 3 # minimum number of nodes
+
+  puts "Nodes: #{t}"
+  som = Ai4r::Som::Som.new 4, 8, Ai4r::Som::TwoPhaseLayer.new(t)
+  som.initiate_map
+
+  puts "global error distance: #{som.global_error(SOM_DATA)}"
+  puts "\ntraining the som\n"
+
+  times = Benchmark.measure do
+    som.train SOM_DATA
+  end
+
+  puts "Elapsed time for training: #{times}"
+  puts "global error distance: #{som.global_error(SOM_DATA)}\n\n"
+end

data/examples/som/som_single_example.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../../lib/ai4r/som/som'
+require File.dirname(__FILE__) + '/som_data'
+require 'benchmark'
+
+som = Ai4r::Som::Som.new 4, 8, Ai4r::Som::TwoPhaseLayer.new(10)
+som.initiate_map
+
+som.nodes.each do |node|
+  p node.weights
+end
+
+puts "global error distance: #{som.global_error(SOM_DATA)}"
+puts "\ntraining the som\n"
+
+times = Benchmark.measure do
+  som.train SOM_DATA
+end
+
+som.nodes.each do |node|
+  p node.weights
+end
+
+puts "Elapsed time for training: #{times}"
+puts "global error distance: #{som.global_error(SOM_DATA)}\n\n"

data/lib/ai4r.rb

@@ -1,29 +1,31 @@
 # Data
-require "ai4r/data/data_set"
-require "ai4r/data/statistics"
-require "ai4r/data/proximity"
-require "ai4r/data/parameterizable"
+require File.dirname(__FILE__) +  "/ai4r/data/data_set"
+require File.dirname(__FILE__) +  "/ai4r/data/statistics"
+require File.dirname(__FILE__) +  "/ai4r/data/proximity"
+require File.dirname(__FILE__) +  "/ai4r/data/parameterizable"
 # Clusterers
-require "ai4r/clusterers/clusterer"
-require "ai4r/clusterers/k_means"
-require "ai4r/clusterers/bisecting_k_means"
-require "ai4r/clusterers/single_linkage"
-require "ai4r/clusterers/complete_linkage"
-require "ai4r/clusterers/average_linkage"
-require "ai4r/clusterers/weighted_average_linkage"
-require "ai4r/clusterers/centroid_linkage"
-require "ai4r/clusterers/median_linkage"
-require "ai4r/clusterers/ward_linkage"
-require "ai4r/clusterers/diana"
+require File.dirname(__FILE__) +  "/ai4r/clusterers/clusterer"
+require File.dirname(__FILE__) +  "/ai4r/clusterers/k_means"
+require File.dirname(__FILE__) +  "/ai4r/clusterers/bisecting_k_means"
+require File.dirname(__FILE__) +  "/ai4r/clusterers/single_linkage"
+require File.dirname(__FILE__) +  "/ai4r/clusterers/complete_linkage"
+require File.dirname(__FILE__) +  "/ai4r/clusterers/average_linkage"
+require File.dirname(__FILE__) +  "/ai4r/clusterers/weighted_average_linkage"
+require File.dirname(__FILE__) +  "/ai4r/clusterers/centroid_linkage"
+require File.dirname(__FILE__) +  "/ai4r/clusterers/median_linkage"
+require File.dirname(__FILE__) +  "/ai4r/clusterers/ward_linkage"
+require File.dirname(__FILE__) +  "/ai4r/clusterers/diana"
 # Classifiers
-require "ai4r/classifiers/classifier"
-require "ai4r/classifiers/id3"
-require "ai4r/classifiers/prism"
-require "ai4r/classifiers/one_r"
-require "ai4r/classifiers/zero_r"
-require "ai4r/classifiers/hyperpipes"
+require File.dirname(__FILE__) +  "/ai4r/classifiers/classifier"
+require File.dirname(__FILE__) +  "/ai4r/classifiers/id3"
+require File.dirname(__FILE__) +  "/ai4r/classifiers/prism"
+require File.dirname(__FILE__) +  "/ai4r/classifiers/one_r"
+require File.dirname(__FILE__) +  "/ai4r/classifiers/zero_r"
+require File.dirname(__FILE__) +  "/ai4r/classifiers/hyperpipes"
 # Neural networks
-require "ai4r/neural_network/backpropagation"
-require "ai4r/neural_network/hopfield"
+require File.dirname(__FILE__) +  "/ai4r/neural_network/backpropagation"
+require File.dirname(__FILE__) +  "/ai4r/neural_network/hopfield"
 # Genetic Algorithms
-require "ai4r/genetic_algorithm/genetic_algorithm"
+require File.dirname(__FILE__) +  "/ai4r/genetic_algorithm/genetic_algorithm"
+# SOM
+require File.dirname(__FILE__) +  "/ai4r/som/som"

data/lib/ai4r/classifiers/prism.rb

@@ -194,3 +194,4 @@ module Ai4r
     end
   end
 end
+

data/lib/ai4r/genetic_algorithm/genetic_algorithm.rb

@@ -178,7 +178,7 @@ module Ai4r
         last_token = @data[0]
         cost = 0
         @data[1..-1].each do |token|
-          cost += @@costs[last_token][token]
+          cost += @@costs.data_items[last_token][token]
           last_token = token
         end
         @fitness = -1 * cost
@@ -220,7 +220,7 @@ module Ai4r
       # In this case, we have implemented edge recombination, wich is the 
       # most used reproduction algorithm for the Travelling salesman problem.
       def self.reproduce(a, b)
-        data_size = @@costs[0].length
+        data_size = @@costs.data_items[0].length
         available = []
         0.upto(data_size-1) { |n| available << n }
         token = a.data[0]
@@ -249,7 +249,7 @@ module Ai4r
       # use some problem domain knowledge, to generate a 
       # (probably) better initial solution.
       def self.seed
-        data_size = @@costs[0].length
+        data_size = @@costs.data_items[0].length
         available = []
         0.upto(data_size-1) { |n| available << n }
         seed = []

data/lib/ai4r/som/layer.rb

@@ -0,0 +1,68 @@
+# Author::    Thomas Kern
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# You can redistribute it and/or modify it under the terms of
+# the Mozilla Public License version 1.1  as published by the
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require File.dirname(__FILE__) + '/../data/parameterizable'
+
+module Ai4r
+
+  module Som
+
+    # responsible for the implementation of the algorithm's decays
+    # currently has methods for the decay of the radius, influence and learning rate.
+    # Has only one phase, which ends after the number of epochs is passed by the Som-class.
+    #
+    # = Parameters
+    # * nodes => number of nodes in the SOM (nodes x nodes). Has to be the same number
+    # you pass to the SOM. Has to be an integer
+    # * radius => the initial radius for the neighborhood
+    # * epochs => number of epochs the algorithm runs, has to be an integer. By default it is set to 100
+    # * learning_rate => sets the initial learning rate
+    class Layer
+
+      include Ai4r::Data::Parameterizable
+
+      parameters_info :nodes => "number of nodes, has to be equal to the som",
+                      :epochs => "number of epochs the algorithm has to run",
+                      :radius => "sets the initial neighborhoud radius"
+
+      def initialize(nodes, radius, epochs = 100, learning_rate = 0.7)
+        raise("Too few nodes") if nodes < 3
+        
+        @nodes = nodes
+        @epochs = epochs
+        @radius = radius
+        @time_for_epoch = @epochs / Math.log(nodes / 4.0)
+        @time_for_epoch = @epochs + 1.0 if @time_for_epoch < @epochs
+
+        @initial_learning_rate = learning_rate
+      end
+
+      # calculates the influnce decay for a certain distance and the current radius
+      # of the epoch
+      def influence_decay(distance, radius)
+        Math.exp(- (distance.to_f**2 / 2.0 / radius.to_f**2))
+      end
+
+      # calculates the radius decay for the current epoch. Uses @time_for_epoch
+      # which has to be higher than the number  of epochs, otherwise the decay will be - Infinity
+      def radius_decay(epoch)
+        (@radius * ( 1 - epoch/ @time_for_epoch)).round
+      end
+
+      # calculates the learning rate decay. uses @time_for_epoch again and same rule applies:
+      # @time_for_epoch has to be higher than the number  of epochs, otherwise the decay will be - Infinity
+      def learning_rate_decay(epoch)
+        @initial_learning_rate * ( 1 - epoch / @time_for_epoch)
+      end
+
+    end
+
+  end
+
+end

data/lib/ai4r/som/node.rb

@@ -0,0 +1,96 @@
+# Author::    Thomas Kern
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# You can redistribute it and/or modify it under the terms of
+# the Mozilla Public License version 1.1  as published by the
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require File.dirname(__FILE__) + '/../data/parameterizable'
+require File.dirname(__FILE__) + '/layer'
+
+module Ai4r
+
+  module Som
+
+    # this class is used for the individual node and will be (nodes * nodes)-time instantiated
+    #
+    # = attributes
+    #
+    # * direct access to the x and y values is granted, those show the position of the node in
+    # the square map
+    # * id => is the uniq and sequential ID of the node
+    # * weights => values of the current weights are stored in an array of dimension 'dimensions'.
+    # Weights are of type float
+    # * instantiated_weight => the values of the first instantiation of weights. these values are
+    # never changed 
+
+    class Node
+
+      include Ai4r::Data::Parameterizable
+
+      parameters_info :weights => "holds the current weight",
+                      :instantiated_weight => "holds the very first weight",
+                      :x => "holds the row ID of the unit in the map",
+                      :y => "holds the column ID of the unit in the map",
+                      :id => "id of the node"      
+
+      # creates an instance of Node and instantiates the weights
+      # the parameters is a uniq and sequential ID as well as the number of total nodes
+      # dimensions signals the dimension of the input vector
+      def self.create(id, total, dimensions)
+        n = Node.new
+        n.id = id
+        n.instantiate_weight dimensions
+        n.x = id % total
+        n.y = (id / total.to_f).to_i
+        n
+      end
+
+      # instantiates the weights to the dimension (of the input vector)
+      # for backup reasons, the instantiated weight is stored into @instantiated_weight  as well
+      def instantiate_weight(dimensions)
+        @weights = Array.new dimensions
+        @instantiated_weight = Array.new dimensions
+        @weights.each_with_index do |weight, index|
+          @weights[index] = rand
+          @instantiated_weight[index] = @weights[index]
+        end
+      end
+
+      # returns the square distance between the current weights and the input
+      # the input is a vector/array of the same size as weights
+      # at the end, the square root is extracted from the sum of differences
+      def distance_to_input(input)
+        dist = 0
+        input.each_with_index do |i, index|
+          dist += (i - @weights[index]) ** 2
+        end
+
+        Math.sqrt(dist)
+      end
+
+      # returns the distance in square-form from the instance node to the passed node
+      # example:
+      # 2 2 2 2 2
+      # 2 1 1 1 2
+      # 2 1 0 1 2
+      # 2 1 1 1 2
+      # 2 2 2 2 2
+      # 0 being the current node
+      def distance_to_node(node)
+        max((self.x - node.x).abs, (self.y - node.y).abs)
+      end
+
+      private
+
+      def max(a, b)
+        a > b ? a : b
+      end
+
+    end
+
+  end
+
+end

data/lib/ai4r/som/som.rb

@@ -0,0 +1,155 @@
+# Author::    Thomas Kern
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# You can redistribute it and/or modify it under the terms of
+# the Mozilla Public License version 1.1  as published by the
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require File.dirname(__FILE__) + '/../data/parameterizable'
+require File.dirname(__FILE__) + '/layer'
+require File.dirname(__FILE__) + '/two_phase_layer'
+require File.dirname(__FILE__) + '/node'
+
+module Ai4r
+
+  # A self-organizing map (SOM) or self-organizing feature map (SOFM) is a type
+  # of artificial neural network that is trained using unsupervised learning to
+  # produce a low-dimensional (typically two-dimensional), discretized
+  # representation of the input space of the training samples, called a map.
+
+  # for more have a look at http://en.wikipedia.org/wiki/Self-organizing_map
+  # an in-depth explanation is provided by Sandhya Samarasinghe in
+  # 'Neural Networks for Applied Sciences and Engineering'
+
+  module Som
+
+    # = Introduction
+    #
+    # This is an implementation of a Kohonen Self-Organizing Maps
+    #
+    # = Features
+    #
+    # * Support for any network architecture (number of layers and neurons)
+    # * Configurable propagation function
+    # * Optional usage of bias
+    # * Configurable momentum
+    # * Configurable learning rate
+    # * Configurable initial weight function
+    # * 100% ruby code, no external dependency
+    #
+    # = Parameters
+    # * dim => dimension of the input vector
+    # * number_of_nodes => is the number of nodes per row/column (square som).
+    # * layer => instante of a layer-algorithm class
+    #
+    # = About the project
+    # Author::    Thomas Kern
+    # License::   MPL 1.1
+    # Url::       http://ai4r.rubyforge.org
+
+    class Som
+
+      include Ai4r::Data::Parameterizable
+
+      parameters_info :nodes  => "sets the architecture of the map (nodes x nodes)",
+                      :dimension => "sets the dimension of the input",
+                      :layer => "instance of a layer, defines how the training algorithm works",
+                      :epoch => "number of finished epochs"
+
+      def initialize(dim, number_of_nodes, layer)
+        @layer = layer
+        @dimension = dim
+        @number_of_nodes = number_of_nodes
+        @nodes = Array.new(number_of_nodes * number_of_nodes)
+        @epoch = 0
+        @cache = {}
+      end
+
+      # finds the best matching unit (bmu) of a certain input in all the @nodes
+      # returns an array of length 2 => [node, distance] (distance is of eucledian type, not
+      # a neighborhood distance)
+      def find_bmu(input)
+        bmu = @nodes.first
+        dist = bmu.distance_to_input input
+        @nodes[1..-1].each do |node|
+          tmp_dist = node.distance_to_input(input)
+          if tmp_dist <= dist
+            dist = tmp_dist
+            bmu = node
+          end
+        end
+        [bmu, dist]
+      end
+
+      # adjusts all nodes within a certain radius to the bmu
+      def adjust_nodes(input, bmu, radius, learning_rate)
+        @nodes.each do |node|
+          dist = node.distance_to_node(bmu[0])
+          next unless dist < radius
+
+          influence = @layer.influence_decay dist, radius
+          node.weights.each_with_index do |weight, index|
+            node.weights[index] +=  influence * learning_rate * (input[index] - weight)
+          end
+        end
+      end
+
+      # main method for the som. trains the map with the passed data vector
+      # calls train_step as long as train_step returns false
+      def train(data)
+        while !train_step(data)
+        end
+      end
+
+      # calculates the global distance error for all data entries
+      def global_error(data)
+        data.inject(0) {|sum,entry| sum + find_bmu(entry)[1]**2 }
+       end
+
+      # trains the map with the data as long as the @epoch is smaller than the epoch-value of
+      # @layer
+      # returns true if @epoch is greater than the fixed epoch-value in @layer, otherwise false
+      # 1 is added to @epoch at each method call
+      # the radius and learning rate is decreased at each method call/epoch as well
+      def train_step(data)
+        return true if @epoch >= @layer.epochs
+
+        radius = @layer.radius_decay @epoch
+        learning_rate = @layer.learning_rate_decay @epoch
+
+        data.each do |entry|
+          adjust_nodes entry, find_bmu(entry), radius, learning_rate
+        end
+
+        @epoch += 1
+        false
+      end
+
+      # returns the node at position (x,y) in the square map
+      def get_node(x, y)
+        raise(Exception.new) if check_param_for_som(x,y)
+        @nodes[y + x * @number_of_nodes]
+      end
+
+      # intitiates the map by creating (@number_of_nodes * @number_of_nodes) nodes
+      def initiate_map
+        @nodes.each_with_index do |node, i|
+          @nodes[i] = Node.create i, @number_of_nodes, @dimension
+        end
+      end
+
+      private
+
+      # checks whether or not there is a node in the map at the coordinates (x,y).
+      # x is the row, y the column indicator
+      def check_param_for_som(x, y)
+        y > @number_of_nodes - 1 || x > @number_of_nodes - 1  || x < 0 || y < 0
+      end
+
+    end
+
+  end
+
+end

data/lib/ai4r/som/two_phase_layer.rb

@@ -0,0 +1,90 @@
+# Author::    Thomas Kern
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# You can redistribute it and/or modify it under the terms of
+# the Mozilla Public License version 1.1  as published by the
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require File.dirname(__FILE__) + '/../data/parameterizable'
+require File.dirname(__FILE__) + '/layer'
+
+module Ai4r
+
+  module Som
+
+    # responsible for the implementation of the algorithm's decays, extends the class Layer.
+    # currently overrides the radius and learning rate decay methods of Layer.
+    # Has two phases, phase one has a decay in both the learning rate and the radius. The number
+    # of epochs for both phases can be passed and the total number of epochs is the sum of epoch
+    # for phase one and phase two.
+    # In the scond phase, the learning and radius decay is steady, normally set to a small number (ie. 0.01)
+    #
+    # = Parameters
+    # * nodes => number of nodes in the SOM (nodes x nodes). Has to be the same number
+    # you pass to the SOM. Has to be an integer
+    # * radius => the initial radius for the neighborhood
+    # * phase_one => number of epochs for phase one, has to be an integer. By default it is set to 150
+    # * phase_two => number of epochs for phase two, has to be an integer. By default it is set to 100
+    # * learning_rate => sets the initial learning rate
+    # * phase_one_learning_rate  => sets the learning rate for phase one
+    # * phase_two_learning_rate  => sets the learning rate for phase two
+
+    class TwoPhaseLayer < Layer
+
+      def initialize(nodes, learning_rate = 0.9, phase_one = 150, phase_two = 100,
+              phase_one_learning_rate = 0.1, phase_two_learning_rate = 0)
+        super nodes, nodes, phase_one + phase_two, learning_rate
+        @phase_one = phase_one
+        @phase_two = phase_two
+        @lr = @initial_learning_rate
+
+        @phase_one_learning_rate = phase_one_learning_rate
+        @phase_two_learning_rate = phase_two_learning_rate
+
+        @radius_reduction = @phase_one / (nodes/2.0 - 1) + 1
+        @delta_lr = (@lr - @phase_one_learning_rate)/ @phase_one
+        @radius = (nodes / 2.0).to_i
+      end
+
+      # two different values will be returned, depending on the phase
+      # in phase one, the radius will incrementially reduced by 1 every @radius_reduction time
+      # in phase two, the radius is fixed to 1
+      def radius_decay(epoch)
+        if epoch > @phase_one
+          return 1
+        else
+          if (epoch % @radius_reduction) == 0
+            @radius -= 1
+          end
+          @radius
+        end
+
+      end
+
+      # two different values will be returned, depending on the phase
+      # in phase one, the rate will incrementially reduced everytime this method is called
+      # on the switch of phases, the learning rate will be reset and the delta_lr (which signals
+      # the decay value of the learning rate) is reset as well
+      # in  phase two, the newly reset delta_lr rate will be used to incrementially reduce the
+      # learning rate
+      def learning_rate_decay(epoch)
+        if epoch < @phase_one
+          @lr -= @delta_lr
+          return @lr
+        elsif epoch == @phase_one
+          @lr = @phase_one_learning_rate
+          @delta_lr = (@phase_one_learning_rate - @phase_two_learning_rate)/@phase_two
+          return @lr
+        else
+          @lr -= @delta_lr
+        end
+      end
+
+    end
+
+  end
+
+end
+

data/test/classifiers/id3_test.rb

@@ -82,14 +82,16 @@ SPLIT_DATA_ITEMS_BY_AGE = [   [
     "elsif age_range=='>80' then marketing_target='Y'\n"+
     "else raise 'There was not enough information during training to do a proper induction for this data element' end"
     
-Ai4r::Classifiers::ID3.send(:public, *Ai4r::Classifiers::ID3.protected_instance_methods)  
-Ai4r::Classifiers::ID3.send(:public, *Ai4r::Classifiers::ID3.private_instance_methods)
-
 include Ai4r::Classifiers
 include Ai4r::Data
 
 class ID3Test < Test::Unit::TestCase
-  
+
+  def test_build
+    Ai4r::Classifiers::ID3.send(:public, *Ai4r::Classifiers::ID3.protected_instance_methods)
+    Ai4r::Classifiers::ID3.send(:public, *Ai4r::Classifiers::ID3.private_instance_methods)
+  end
+
   def test_log2
     assert_equal 1.0, ID3.log2(2)
     assert_equal 0.0, ID3.log2(0)

data/test/classifiers/prism_test.rb

@@ -1,14 +1,12 @@
 require 'test/unit'
 require File.dirname(__FILE__) + '/../../lib/ai4r/classifiers/prism'
 
-Ai4r::Classifiers::Prism.send(:public, *Ai4r::Classifiers::Prism.protected_instance_methods)  
-Ai4r::Classifiers::Prism.send(:public, *Ai4r::Classifiers::Prism.private_instance_methods)
 
 class PrismTest < Test::Unit::TestCase
   
   include Ai4r::Classifiers
   include Ai4r::Data
-  
+
   @@data_examples = [   ['New York',  '<30',      'M', 'Y'],
                 ['Chicago',     '<30',      'M', 'Y'],
                 ['Chicago',     '<30',      'F', 'Y'],
@@ -42,6 +40,9 @@ class PrismTest < Test::Unit::TestCase
     assert_equal("city", classifier.data_set.data_labels.first)
     assert_equal("marketing_target", classifier.data_set.data_labels.last)
     assert !classifier.rules.empty?
+
+    Prism.send(:public, *Prism.protected_instance_methods)
+    Prism.send(:public, *Prism.private_instance_methods)
   end
   
   def test_eval
@@ -76,6 +77,7 @@ class PrismTest < Test::Unit::TestCase
   def test_matches_conditions
     classifier = Prism.new.build(DataSet.new(:data_labels => @@data_labels,
       :data_items => @@data_examples))
+
     assert classifier.matches_conditions(['New York', '<30', 'M', 'Y'], {"age_range" => "<30"})
     assert !classifier.matches_conditions(['New York', '<30', 'M', 'Y'], {"age_range" => "[50-80]"})
   end

data/test/clusterers/average_linkage_test.rb

@@ -12,8 +12,6 @@ require File.dirname(__FILE__) + '/../../lib/ai4r/clusterers/average_linkage'
 
 class Ai4r::Clusterers::AverageLinkage < Ai4r::Clusterers::SingleLinkage
   attr_accessor :data_set, :number_of_clusters, :clusters, :distance_matrix
-  public :linkage_distance
-  public :distance_between_item_and_cluster
 end
 
 class AverageLinkageTest < Test::Unit::TestCase
@@ -36,6 +34,11 @@ class AverageLinkageTest < Test::Unit::TestCase
         [68.0, 26.0, 9.0, 0.0, 10.0, 68.0, 5.0, 52.0, 16.0], 
         [49.0, 49.0, 26.0, 5.0, 25.0, 49.0, 4.0, 29.0, 37.0, 5.0], 
         [2.0, 72.0, 65.0, 50.0, 52.0, 2.0, 65.0, 10.0, 74.0, 50.0, 37.0]]
+      
+   def setup
+     Ai4r::Clusterers::AverageLinkage.send(:public, 
+       *Ai4r::Clusterers::AverageLinkage.protected_instance_methods)  
+   end
   
    def test_linkage_distance
     clusterer = Ai4r::Clusterers::AverageLinkage.new

data/test/clusterers/centroid_linkage_test.rb

@@ -12,8 +12,6 @@ require File.dirname(__FILE__) + '/../../lib/ai4r/clusterers/centroid_linkage'
 
 class Ai4r::Clusterers::CentroidLinkage
   attr_accessor :data_set, :number_of_clusters, :clusters, :distance_matrix, :index_clusters
-  public :linkage_distance
-  public :create_initial_index_clusters
 end
 
 class Ai4r::Clusterers::CentroidLinkageTest < Test::Unit::TestCase
@@ -37,6 +35,11 @@ class Ai4r::Clusterers::CentroidLinkageTest < Test::Unit::TestCase
         [49.0, 49.0, 26.0, 5.0, 25.0, 49.0, 4.0, 29.0, 37.0, 5.0], 
         [2.0, 72.0, 65.0, 50.0, 52.0, 2.0, 65.0, 10.0, 74.0, 50.0, 37.0]]
   
+   def setup
+     Ai4r::Clusterers::CentroidLinkage.send(:public, 
+       *Ai4r::Clusterers::CentroidLinkage.protected_instance_methods)  
+   end
+  
    def test_linkage_distance
     clusterer = Ai4r::Clusterers::CentroidLinkage.new
     clusterer.data_set = DataSet.new :data_items => @@data

data/test/clusterers/complete_linkage_test.rb

@@ -12,8 +12,6 @@ require File.dirname(__FILE__) + '/../../lib/ai4r/clusterers/complete_linkage'
 
 class Ai4r::Clusterers::CompleteLinkage
   attr_accessor :data_set, :number_of_clusters, :clusters, :distance_matrix
-  public :linkage_distance
-  public :distance_between_item_and_cluster
 end
 
 class CompleteLinkageTest < Test::Unit::TestCase
@@ -36,6 +34,11 @@ class CompleteLinkageTest < Test::Unit::TestCase
         [68.0, 26.0, 9.0, 0.0, 10.0, 68.0, 5.0, 52.0, 16.0], 
         [49.0, 49.0, 26.0, 5.0, 25.0, 49.0, 4.0, 29.0, 37.0, 5.0], 
         [2.0, 72.0, 65.0, 50.0, 52.0, 2.0, 65.0, 10.0, 74.0, 50.0, 37.0]]
+      
+   def setup
+     Ai4r::Clusterers::CompleteLinkage.send(:public, 
+       *Ai4r::Clusterers::CompleteLinkage.protected_instance_methods)  
+   end
   
    def test_linkage_distance
     clusterer = Ai4r::Clusterers::CompleteLinkage.new

data/test/clusterers/median_linkage_test.rb

@@ -12,8 +12,6 @@ require File.dirname(__FILE__) + '/../../lib/ai4r/clusterers/median_linkage'
 
 class Ai4r::Clusterers::MedianLinkage
   attr_accessor :data_set, :number_of_clusters, :clusters, :distance_matrix, :index_clusters
-  public :linkage_distance
-  public :create_initial_index_clusters
 end
 
 class Ai4r::Clusterers::MedianLinkageTest < Test::Unit::TestCase
@@ -36,6 +34,11 @@ class Ai4r::Clusterers::MedianLinkageTest < Test::Unit::TestCase
         [68.0, 26.0, 9.0, 0.0, 10.0, 68.0, 5.0, 52.0, 16.0], 
         [49.0, 49.0, 26.0, 5.0, 25.0, 49.0, 4.0, 29.0, 37.0, 5.0], 
         [2.0, 72.0, 65.0, 50.0, 52.0, 2.0, 65.0, 10.0, 74.0, 50.0, 37.0]]
+      
+   def setup
+     Ai4r::Clusterers::MedianLinkage.send(:public, 
+       *Ai4r::Clusterers::MedianLinkage.protected_instance_methods)  
+   end
   
    def test_linkage_distance
     clusterer = Ai4r::Clusterers::MedianLinkage.new

data/test/clusterers/ward_linkage_test.rb

@@ -12,8 +12,6 @@ require File.dirname(__FILE__) + '/../../lib/ai4r/clusterers/ward_linkage'
 
 class Ai4r::Clusterers::WardLinkage
   attr_accessor :data_set, :number_of_clusters, :clusters, :distance_matrix, :index_clusters
-  public :linkage_distance
-  public :create_initial_index_clusters
 end
 
 class Ai4r::Clusterers::WardLinkageTest < Test::Unit::TestCase
@@ -36,7 +34,12 @@ class Ai4r::Clusterers::WardLinkageTest < Test::Unit::TestCase
         [68.0, 26.0, 9.0, 0.0, 10.0, 68.0, 5.0, 52.0, 16.0], 
         [49.0, 49.0, 26.0, 5.0, 25.0, 49.0, 4.0, 29.0, 37.0, 5.0], 
         [2.0, 72.0, 65.0, 50.0, 52.0, 2.0, 65.0, 10.0, 74.0, 50.0, 37.0]]
-  
+      
+   def setup
+     Ai4r::Clusterers::WardLinkage.send(:public, 
+       *Ai4r::Clusterers::WardLinkage.protected_instance_methods)  
+   end
+   
    def test_linkage_distance
     clusterer = Ai4r::Clusterers::WardLinkage.new
     clusterer.data_set = DataSet.new :data_items => @@data

data/test/clusterers/weighted_average_linkage_test.rb

@@ -12,8 +12,6 @@ require File.dirname(__FILE__) + '/../../lib/ai4r/clusterers/weighted_average_li
 
 class Ai4r::Clusterers::WeightedAverageLinkage
   attr_accessor :data_set, :number_of_clusters, :clusters, :distance_matrix, :index_clusters
-  public :linkage_distance
-  public :create_initial_index_clusters
 end
 
 class Ai4r::Clusterers::WeightedAverageLinkageTest < Test::Unit::TestCase
@@ -36,6 +34,11 @@ class Ai4r::Clusterers::WeightedAverageLinkageTest < Test::Unit::TestCase
         [68.0, 26.0, 9.0, 0.0, 10.0, 68.0, 5.0, 52.0, 16.0], 
         [49.0, 49.0, 26.0, 5.0, 25.0, 49.0, 4.0, 29.0, 37.0, 5.0], 
         [2.0, 72.0, 65.0, 50.0, 52.0, 2.0, 65.0, 10.0, 74.0, 50.0, 37.0]]
+      
+   def setup
+     Ai4r::Clusterers::WeightedAverageLinkage.send(:public, 
+       *Ai4r::Clusterers::WeightedAverageLinkage.protected_instance_methods)  
+   end
   
    def test_linkage_distance
     clusterer = Ai4r::Clusterers::WeightedAverageLinkage.new

data/test/som/som_test.rb

@@ -0,0 +1,97 @@
+# This is a unit test file for the SOM algorithm implemented
+# in ai4r
+#
+# Author::    Thomas Kern
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       http://ai4r.rubyforge.org/
+#
+# You can redistribute it and/or modify it under the terms of
+# the Mozilla Public License version 1.1  as published by the
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require File.dirname(__FILE__) + '/../../lib/ai4r/som/som'
+require 'test/unit'
+
+module Ai4r
+
+  module Som
+
+    class SomTest < Test::Unit::TestCase
+
+      def setup
+        @som = Som.new 2, 5, Layer.new(3, 3)
+        @som.initiate_map
+      end
+
+      def test_random_initiation
+        assert_equal 25, @som.nodes.length
+
+        @som.nodes.each do |node|
+          assert_equal 2, node.weights.length
+
+          node.weights.each do |weight|
+            assert weight < 1
+            assert weight > 0
+          end
+
+        end
+      end
+
+
+      # bmu
+
+      def test_find_bmu
+        bmu = @som.find_bmu([0.5, 0.5])
+      end
+
+      def test_adjust_nodes
+        @som.adjust_nodes [1, 2], @som.find_bmu([0.5, 0.5]), 2, 0.1
+      end
+
+      def test_access_to_nodes
+        assert_raise Exception do
+          @som.get_node(5, 5)
+        end
+
+        assert_raise Exception do
+          @som.get_node(5, -3)
+        end
+
+        assert_equal Node, @som.get_node(0, 0).class
+      end
+
+      def test_distance_for_same_row
+        assert_equal 2, distancer(0, 0, 0, 2)
+        assert_equal 2, distancer(0, 4, 0, 2)
+        assert_equal 0, distancer(0, 0, 0, 0)
+      end
+
+      def test_distance_for_same_column
+        assert_equal 1, distancer(0, 0, 1, 0)
+        assert_equal 2, distancer(2, 0, 0, 0)
+      end
+
+      def test_distance_for_diagonally_point
+        assert_equal 1, distancer(1, 0, 0, 1)
+        assert_equal 2, distancer(2, 2, 0, 0)
+        assert_equal 2, distancer(3, 2, 1, 4)
+      end
+
+      def test_distance_for_screwed_diagonally_point
+        assert_equal 2, distancer(0, 0, 2, 1)
+        assert_equal 4, distancer(3, 4, 1, 0)
+        assert_equal 2, distancer(3, 2, 1, 3)
+      end
+
+      private
+
+      def distancer(x1, y1, x2, y2)
+        @som.get_node(x1, y1).distance_to_node(@som.get_node(x2, y2))
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -1,125 +1,127 @@
 --- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
 name: ai4r
 version: !ruby/object:Gem::Version 
-  version: "1.7"
+  version: "1.8"
+date: 2009-06-15 00:00:00 +01:00
+summary: Ruby implementations of algorithms covering several Artificial intelligence fields, including Genetic algorithms, Neural Networks, machine learning, and clustering.
+require_paths: 
+- lib
+email: sergio@jadeferret.com
+homepage: http://ai4r.rubyforge.org
+rubyforge_project: ai4r
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
 platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
 authors: 
 - Sergio Fierens
-autorequire: 
-bindir: bin
-cert_chain: []
-
-date: 2009-04-29 00:00:00 +01:00
-default_executable: 
-dependencies: []
-
-description: 
-email: sergio@jadeferret.com
-executables: []
-
-extensions: []
-
-extra_rdoc_files: 
-- README.rdoc
 files: 
 - examples/clusterers
-- examples/clusterers/simple_website_clustering.rb
-- examples/neural_network
-- examples/neural_network/backpropagation_example.rb
-- examples/neural_network/patterns_with_base_noise.rb
-- examples/neural_network/xor_example.rb
-- examples/neural_network/patterns_with_noise.rb
-- examples/neural_network/training_patterns.rb
 - examples/decision_trees
 - examples/decision_trees/data_set.csv
-- examples/decision_trees/results.txt
 - examples/decision_trees/id3_example.rb
+- examples/decision_trees/results.txt
 - examples/genetic_algorithm
 - examples/genetic_algorithm/genetic_algorithm_example.rb
 - examples/genetic_algorithm/travel_cost.csv
-- lib/ai4r.rb
+- examples/neural_network
+- examples/neural_network/backpropagation_example.rb
+- examples/neural_network/patterns_with_base_noise.rb
+- examples/neural_network/patterns_with_noise.rb
+- examples/neural_network/training_patterns.rb
+- examples/neural_network/xor_example.rb
+- examples/som
+- examples/som/som_data.rb
+- examples/som/som_multi_node_example.rb
+- examples/som/som_single_example.rb
 - lib/ai4r
+- lib/ai4r/classifiers
+- lib/ai4r/classifiers/classifier.rb
+- lib/ai4r/classifiers/hyperpipes.rb
+- lib/ai4r/classifiers/id3.rb
+- lib/ai4r/classifiers/multilayer_perceptron.rb
+- lib/ai4r/classifiers/one_r.rb
+- lib/ai4r/classifiers/prism.rb
+- lib/ai4r/classifiers/zero_r.rb
 - lib/ai4r/clusterers
 - lib/ai4r/clusterers/average_linkage.rb
-- lib/ai4r/clusterers/median_linkage.rb
+- lib/ai4r/clusterers/bisecting_k_means.rb
 - lib/ai4r/clusterers/centroid_linkage.rb
-- lib/ai4r/clusterers/weighted_average_linkage.rb
+- lib/ai4r/clusterers/clusterer.rb
 - lib/ai4r/clusterers/complete_linkage.rb
 - lib/ai4r/clusterers/diana.rb
-- lib/ai4r/clusterers/bisecting_k_means.rb
-- lib/ai4r/clusterers/ward_linkage.rb
-- lib/ai4r/clusterers/single_linkage.rb
 - lib/ai4r/clusterers/k_means.rb
-- lib/ai4r/clusterers/clusterer.rb
+- lib/ai4r/clusterers/median_linkage.rb
+- lib/ai4r/clusterers/single_linkage.rb
+- lib/ai4r/clusterers/ward_linkage.rb
+- lib/ai4r/clusterers/weighted_average_linkage.rb
+- lib/ai4r/data
+- lib/ai4r/data/data_set.rb
+- lib/ai4r/data/parameterizable.rb
+- lib/ai4r/data/proximity.rb
+- lib/ai4r/data/statistics.rb
 - lib/ai4r/experiment
 - lib/ai4r/experiment/classifier_evaluator.rb
+- lib/ai4r/genetic_algorithm
+- lib/ai4r/genetic_algorithm/genetic_algorithm.rb
 - lib/ai4r/neural_network
 - lib/ai4r/neural_network/backpropagation.rb
 - lib/ai4r/neural_network/hopfield.rb
-- lib/ai4r/classifiers
-- lib/ai4r/classifiers/hyperpipes.rb
-- lib/ai4r/classifiers/multilayer_perceptron.rb
-- lib/ai4r/classifiers/prism.rb
-- lib/ai4r/classifiers/one_r.rb
-- lib/ai4r/classifiers/zero_r.rb
-- lib/ai4r/classifiers/classifier.rb
-- lib/ai4r/classifiers/id3.rb
-- lib/ai4r/genetic_algorithm
-- lib/ai4r/genetic_algorithm/genetic_algorithm.rb
-- lib/ai4r/data
-- lib/ai4r/data/parameterizable.rb
-- lib/ai4r/data/statistics.rb
-- lib/ai4r/data/data_set.rb
-- lib/ai4r/data/proximity.rb
+- lib/ai4r/som
+- lib/ai4r/som/layer.rb
+- lib/ai4r/som/node.rb
+- lib/ai4r/som/som.rb
+- lib/ai4r/som/two_phase_layer.rb
+- lib/ai4r.rb
 - README.rdoc
-has_rdoc: true
-homepage: http://ai4r.rubyforge.org
-post_install_message: 
-rdoc_options: []
-
-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: ai4r
-rubygems_version: 1.3.1
-signing_key: 
-specification_version: 2
-summary: Ruby implementations of algorithms covering several Artificial intelligence fields, including Genetic algorithms, Neural Networks, machine learning, and clustering.
 test_files: 
-- test/clusterers/single_linkage_test.rb
-- test/clusterers/weighted_average_linkage_test.rb
-- test/clusterers/diana_test.rb
+- test/classifiers/hyperpipes_test.rb
+- test/classifiers/id3_test.rb
+- test/classifiers/multilayer_perceptron_test.rb
+- test/classifiers/one_r_test.rb
+- test/classifiers/prism_test.rb
+- test/classifiers/zero_r_test.rb
 - test/clusterers/average_linkage_test.rb
-- test/clusterers/median_linkage_test.rb
-- test/clusterers/ward_linkage_test.rb
-- test/clusterers/complete_linkage_test.rb
+- test/clusterers/bisecting_k_means_test.rb
 - test/clusterers/centroid_linkage_test.rb
+- test/clusterers/complete_linkage_test.rb
+- test/clusterers/diana_test.rb
 - test/clusterers/k_means_test.rb
-- test/clusterers/bisecting_k_means_test.rb
+- test/clusterers/median_linkage_test.rb
+- test/clusterers/single_linkage_test.rb
+- test/clusterers/ward_linkage_test.rb
+- test/clusterers/weighted_average_linkage_test.rb
+- test/data/data_set_test.rb
+- test/data/proximity_test.rb
+- test/data/statistics_test.rb
 - test/experiment/classifier_evaluator_test.rb
-- test/neural_network/hopfield_test.rb
-- test/neural_network/backpropagation_test.rb
-- test/classifiers/zero_r_test.rb
-- test/classifiers/multilayer_perceptron_test.rb
-- test/classifiers/prism_test.rb
-- test/classifiers/one_r_test.rb
-- test/classifiers/hyperpipes_test.rb
-- test/classifiers/id3_test.rb
-- test/genetic_algorithm/genetic_algorithm_test.rb
 - test/genetic_algorithm/chromosome_test.rb
-- test/data/statistics_test.rb
-- test/data/proximity_test.rb
-- test/data/data_set_test.rb
+- test/genetic_algorithm/genetic_algorithm_test.rb
+- test/neural_network/backpropagation_test.rb
+- test/neural_network/hopfield_test.rb
+- test/som/som_test.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README.rdoc
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+

data/examples/clusterers/simple_website_clustering.rb

@@ -1,47 +0,0 @@
-require File.dirname(__FILE__) + '/google_search'
-require File.dirname(__FILE__) + '/build_keywords'
-require File.dirname(__FILE__) + '/../../lib/ai4r/clusterers/average_linkage'
-require 'rubygems'
-require 'hpricot'
-require 'net/http'
-require 'benchmark'
-
-SITES_TO_CLASSIFY = [
-  "www.foxnews.com", "www.usatoday.com", "scm.jadeferret.com",
-  "www.accurev.com", "www.lastminute.com", "subversion.tigris.org",
-  "news.yahoo.com", "news.bbc.co.uk", "www.orbitz.com"
-]
-  
-# Return array of keywords for the site
-def get_keywords(site)
-  response = Net::HTTP.get_response(site, "/")
-  Hpricot(response.body).
-    search("meta[@name='keywords']")[0]. #Select meta keywords element
-    attributes["content"].               #Select its content
-    split(",").                          #Keywords are coma separated
-    collect{ |k| k.strip.downcase }      #Remove start and end white spaces
-end
-
-# Get keywords data for each website
-Site = Struct.new("Site", :name, :keywords)
-sites = SITES_TO_CLASSIFY.collect do |site_name|
-  Site.new(site_name, get_keywords(site_name))
-end
-data_set = Ai4r::Data::DataSet.new(:data_items => sites, 
-  :data_labels => Site.members)
-
-# The distance between sites depends on the keywords collected from internet 
-keywords_distance_function = lambda do |x,y| 
-  return Ai4r::Data::Proximity.simple_matching(x.keyword, y.keywords)
-end
-
-# Create the clusters
-clusterer = Ai4r::Clusterers::AverageLinkage.new
-clusterer.distance_function = keywords_distance_function
-clusterer.build(data_set, 3)
-
-# Print results
-clusterer.clusters.each do |cluster|
-  puts cluster.data_items.collect {|item| item.name}.join(", ")
-  puts "============"
-end