ai4ruby 1.11

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/hyperpipes_test.rb

@@ -0,0 +1,84 @@
+# Author::    Sergio Fierens
+# 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/classifiers/hyperpipes'
+require 'test/unit'
+
+class Ai4r::Classifiers::Hyperpipes
+  attr_accessor :data_set, :pipes
+end
+
+include Ai4r::Classifiers
+include Ai4r::Data
+
+class HyperpipesTest < Test::Unit::TestCase
+
+  @@data_labels = [ 'city', 'age', 'gender', 'marketing_target'  ]
+
+  @@data_items = [['New York',  25, 'M', 'Y'],
+              ['New York',  23, 'M', 'Y'],
+              ['New York',  18, 'M', 'Y'],
+              ['Chicago',   43, 'M', 'Y'],
+              ['New York',  34, 'F', 'N'],
+              ['Chicago',   33, 'F', 'Y'],
+              ['New York',  31, 'F', 'N'],
+              ['Chicago',   55, 'M', 'N'],
+              ['New York',  58, 'F', 'N'],
+              ['New York',  59, 'M', 'N'],
+              ['Chicago',   71, 'M', 'N'],
+              ['New York',  60, 'F', 'N'],
+              ['Chicago',   85, 'F', 'Y']
+            ]
+  
+  
+  def setup
+    Hyperpipes.send(:public, *Hyperpipes.protected_instance_methods)
+    @data_set = DataSet.new(:data_items => @@data_items, :data_labels => @@data_labels)
+  end
+  
+  def test_build_pipe
+    classifier = Hyperpipes.new
+    assert_equal [{}, {:max=>-1.0/0, :min=>1.0/0}, {}], classifier.build_pipe(@data_set)
+  end
+  
+  def test_get_rules
+    
+  end
+  
+  def test_build
+    assert_raise(ArgumentError) { Hyperpipes.new.build(DataSet.new) }
+    classifier = Hyperpipes.new.build(@data_set)
+    assert classifier.pipes.include?("Y")
+    assert classifier.pipes.include?("N")
+  end
+
+  def test_eval
+    classifier = Hyperpipes.new.build(@data_set)
+    assert classifier
+    assert_equal('N', classifier.eval(['Chicago',  55, 'M']))
+    assert_equal('N', classifier.eval(['New York', 35, 'F']))
+    assert_equal('Y', classifier.eval(['New York', 25, 'M']))
+    assert_equal('Y', classifier.eval(['Chicago',  85, 'F'])) 
+  end
+
+  def test_get_rules
+    classifier = Hyperpipes.new.build(@data_set)
+    age = 28
+    gender = "M"
+    marketing_target = nil
+    eval classifier.get_rules
+    assert_equal 'Y', marketing_target
+    age = 44 
+    city='New York'
+    eval classifier.get_rules
+    assert_equal 'N', marketing_target
+  end
+end
+
+