nirvdrum-ai4r 1.9.1

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/site/forrest.properties

@@ -0,0 +1,152 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+##############
+# These are the defaults, un-comment them only if you need to change them.
+#
+# You can even have a completely empty file, to assist with maintenance.
+# This file is required, even if empty.
+#
+# The file obtained from 'forrest seed-sample' shows the defaults.
+##############
+
+# Prints out a summary of Forrest settings for this project
+#forrest.echo=true
+
+# Project name (used to name .war file)
+#project.name=my-project
+
+# Specifies name of Forrest skin to use
+# See list at http://forrest.apache.org/docs/skins.html
+#project.skin=pelt
+
+# Descriptors for plugins and skins
+# comma separated list, file:// is supported
+#forrest.skins.descriptors=http://forrest.apache.org/skins/skins.xml,file:///c:/myskins/skins.xml
+#forrest.plugins.descriptors=http://forrest.apache.org/plugins/plugins.xml,http://forrest.apache.org/plugins/whiteboard-plugins.xml
+
+##############
+# behavioural properties
+#project.menu-scheme=tab_attributes
+#project.menu-scheme=directories
+
+##############
+# layout properties
+
+# Properties that can be set to override the default locations
+#
+# Parent properties must be set. This usually means uncommenting
+# project.content-dir if any other property using it is uncommented
+
+#project.status=status.xml
+#project.content-dir=src/documentation
+#project.raw-content-dir=${project.content-dir}/content
+#project.conf-dir=${project.content-dir}/conf
+#project.sitemap-dir=${project.content-dir}
+#project.xdocs-dir=${project.content-dir}/content/xdocs
+#project.resources-dir=${project.content-dir}/resources
+#project.stylesheets-dir=${project.resources-dir}/stylesheets
+#project.images-dir=${project.resources-dir}/images
+#project.schema-dir=${project.resources-dir}/schema
+#project.skins-dir=${project.content-dir}/skins
+#project.skinconf=${project.content-dir}/skinconf.xml
+#project.lib-dir=${project.content-dir}/lib
+#project.classes-dir=${project.content-dir}/classes
+#project.translations-dir=${project.content-dir}/translations
+
+#project.build-dir=${project.home}/build
+#project.site=site
+#project.site-dir=${project.build-dir}/${project.site}
+#project.temp-dir=${project.build-dir}/tmp
+
+##############
+# Cocoon catalog entity resolver properties
+# A local OASIS catalog file to supplement the default Forrest catalog
+#project.catalog=${project.schema-dir}/catalog.xcat
+
+##############
+# validation properties
+
+# This set of properties determine if validation is performed
+# Values are inherited unless overridden.
+# e.g. if forrest.validate=false then all others are false unless set to true.
+#forrest.validate=true
+#forrest.validate.xdocs=${forrest.validate}
+#forrest.validate.skinconf=${forrest.validate}
+#forrest.validate.sitemap=${forrest.validate}
+#forrest.validate.stylesheets=${forrest.validate}
+#forrest.validate.skins=${forrest.validate}
+#forrest.validate.skins.stylesheets=${forrest.validate.skins}
+
+# *.failonerror=(true|false) - stop when an XML file is invalid
+#forrest.validate.failonerror=true
+
+# *.excludes=(pattern) - comma-separated list of path patterns to not validate
+# Note: If you do add an "excludes" list then you need to specify site.xml too.
+# e.g.
+#forrest.validate.xdocs.excludes=site.xml, samples/subdir/**, samples/faq.xml
+#forrest.validate.xdocs.excludes=site.xml
+
+
+##############
+# General Forrest properties
+
+# The URL to start crawling from
+#project.start-uri=linkmap.html
+
+# Set logging level for messages printed to the console
+# (DEBUG, INFO, WARN, ERROR, FATAL_ERROR)
+#project.debuglevel=ERROR
+
+# Max memory to allocate to Java
+#forrest.maxmemory=64m
+
+# Any other arguments to pass to the JVM. For example, to run on an X-less
+# server, set to -Djava.awt.headless=true
+#forrest.jvmargs=
+
+# The bugtracking URL - the issue number will be appended
+# Projects would use their own issue tracker, of course.
+#project.bugtracking-url=http://issues.apache.org/bugzilla/show_bug.cgi?id=
+#project.bugtracking-url=http://issues.apache.org/jira/browse/
+
+# The issues list as rss
+#project.issues-rss-url=
+
+#I18n Property. Based on the locale request for the browser.
+#If you want to use it for static site then modify the JVM system.language
+# and run once per language
+project.i18n=true
+
+# The names of plugins that are required to build the project
+# comma separated list (no spaces)
+# You can request a specific version by appending "-VERSION" to the end of
+# the plugin name. If you exclude a version number, the latest released version
+# will be used. However, be aware that this may be a development version. In
+# a production environment it is recommended that you specify a known working
+# version.
+# Run "forrest available-plugins" for a list of plug-ins currently available.
+project.required.plugins=org.apache.forrest.plugin.output.pdf
+
+# codename: Dispatcher
+# Add the following plugins to project.required.plugins:
+#org.apache.forrest.plugin.internal.dispatcher,org.apache.forrest.themes.core,org.apache.forrest.plugin.output.inputModule
+
+# Proxy configuration
+# - proxy.user and proxy.password are only needed if the proxy is an authenticated one...
+# proxy.host=myproxy.myhost.com
+# proxy.port=<ProxyPort>
+# proxy.user=<login, if authenticated proxy>
+# proxy.password=<password, if authenticated proxy>