reddavis-mlp 0.0.0

data/.autotest

@@ -0,0 +1 @@
+require 'redgreen/autotest'

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,46 @@
+= Multi-Layer Perceptron Neural Network
+
+I built this to not only learn about the MLP but to also make a very simple, well laid out MLP so other can easily see what's happening.
+
+I also suggest checking out http://bit.ly/XEWOc for a great tutorial.
+
+== Install
+
+  gem sources -a http://gems.github.com
+  sudo gem install reddavis-mlp
+
+== How To Use
+  require 'rubygems'
+  require 'mlp'
+  
+  a = MLP.new(:hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+
+  3001.times do |i|
+    a.train([0,0], [0])
+    a.train([0,1], [1])
+    a.train([1,0], [1])
+    error = a.train([1,1], [0])
+    puts "Error after iteration #{i}:\t#{error}" if i%200 == 0
+  end
+
+  puts "Test data"
+  puts "[0,0] = > #{a.feed_forward([0,0]).inspect}"
+  puts "[0,1] = > #{a.feed_forward([0,1]).inspect}"
+  puts "[1,0] = > #{a.feed_forward([1,0]).inspect}"
+  puts "[1,1] = > #{a.feed_forward([1,1]).inspect}"
+  
+== Benchmarks
+
+  The above example produces these times
+  
+           user     system      total        real
+  MLP    0.820000   0.000000   0.820000 (  0.837693)
+  Ai4R   1.180000   0.010000   1.190000 (  1.232388)
+
+== 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 = "mlp"
+    gem.summary = %Q{Multi-Layer Perceptron Neural Network in Ruby}
+    gem.description = %Q{Multi-Layer Perceptron Neural Network in Ruby}
+    gem.email = "reddavis@gmail.com"
+    gem.homepage = "http://github.com/reddavis/mlp"
+    gem.authors = ["reddavis"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+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 = "mlp #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/examples/backpropagation_example.rb

@@ -0,0 +1,73 @@
+# This test was taken from ai4r gem
+
+# 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__) + '/training_patterns'
+require File.dirname(__FILE__) + '/patterns_with_noise'
+require File.dirname(__FILE__) + '/patterns_with_base_noise'
+require File.dirname(__FILE__) + '/../lib/mlp'
+require 'benchmark'
+
+times = Benchmark.measure do
+  
+    srand 1
+  
+    net = MLP.new(:hidden_layers => [2], :output_nodes => 3, :inputs => 256)
+    
+    tr_with_noise = TRIANGLE_WITH_NOISE.flatten.collect { |input| input.to_f / 5.0}
+    sq_with_noise = SQUARE_WITH_NOISE.flatten.collect { |input| input.to_f / 5.0}
+    cr_with_noise = CROSS_WITH_NOISE.flatten.collect { |input| input.to_f / 5.0}
+
+    tr_with_base_noise = TRIANGLE_WITH_BASE_NOISE.flatten.collect { |input| input.to_f / 5.0}
+    sq_with_base_noise = SQUARE_WITH_BASE_NOISE.flatten.collect { |input| input.to_f / 5.0}
+    cr_with_base_noise = CROSS_WITH_BASE_NOISE.flatten.collect { |input| input.to_f / 5.0}
+    
+    puts "Training the network, please wait."
+    101.times do |i|
+      tr_input = TRIANGLE.flatten.collect { |input| input.to_f / 5.0}
+      sq_input = SQUARE.flatten.collect { |input| input.to_f / 5.0}
+      cr_input = CROSS.flatten.collect { |input| input.to_f / 5.0}
+      
+      error1 = net.train(tr_input, [1,0,0])
+      error2 = net.train(sq_input, [0,1,0])
+      error3 = net.train(cr_input, [0,0,1])
+      puts "Error after iteration #{i}:\t#{error1} - #{error2} - #{error3}" if i%20 == 0
+    end
+
+    def result_label(result)
+      if result[0] > result[1] && result[0] > result[2]
+        "TRIANGLE"
+      elsif result[1] > result[2] 
+        "SQUARE"
+      else    
+        "CROSS"
+      end
+    end
+    
+    tr_input = TRIANGLE.flatten.collect { |input| input.to_f / 5.0}
+    sq_input = SQUARE.flatten.collect { |input| input.to_f / 5.0}
+    cr_input = CROSS.flatten.collect { |input| input.to_f / 5.0}
+
+    puts "Training Examples"
+    puts "#{net.feed_forward(tr_input).inspect} => #{result_label(net.feed_forward(tr_input))}"
+    puts "#{net.feed_forward(sq_input).inspect} => #{result_label(net.feed_forward(sq_input))}"
+    puts "#{net.feed_forward(cr_input).inspect} => #{result_label(net.feed_forward(cr_input))}"
+    puts "Examples with noise"
+    puts "#{net.feed_forward(tr_with_noise).inspect} => #{result_label(net.feed_forward(tr_with_noise))}"
+    puts "#{net.feed_forward(sq_with_noise).inspect} => #{result_label(net.feed_forward(sq_with_noise))}"
+    puts "#{net.feed_forward(cr_with_noise).inspect} => #{result_label(net.feed_forward(cr_with_noise))}"
+    puts "Examples with base noise"
+    puts "#{net.feed_forward(tr_with_base_noise).inspect} => #{result_label(net.feed_forward(tr_with_base_noise))}"
+    puts "#{net.feed_forward(sq_with_base_noise).inspect} => #{result_label(net.feed_forward(sq_with_base_noise))}"
+    puts "#{net.feed_forward(cr_with_base_noise).inspect} => #{result_label(net.feed_forward(cr_with_base_noise))}"
+  
+end
+
+puts "Elapsed time: #{times}"

data/examples/patterns_with_base_noise.rb

@@ -0,0 +1,68 @@
+# 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
+ 
+
+TRIANGLE_WITH_BASE_NOISE = [
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  3,  4, 10, 10,  4,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  3,  8,  8,  8,  8,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  4, 10,  4,  4, 10,  4,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  8,  8,  3,  3,  8,  8,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  4, 10,  4,  3,  3,  4, 10,  4,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3],
+  [ 3,  3,  3,  4, 10,  4,  3,  3,  3,  3,  4, 10,  4,  3,  3,  3],
+  [ 3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3],
+  [ 3,  3,  4, 10,  4,  3,  3,  3,  3,  3,  3,  4, 10,  4,  3,  3],
+  [ 3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3],
+  [ 3,  4, 10,  4,  3,  3,  3,  3,  3,  3,  3,  3,  4, 10,  4,  3],
+  [ 3,  8,  8,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  8,  8,  3],
+  [ 4, 10,  4,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  4, 10,  4],
+  [ 8,  8,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  8,  8],
+  [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
+]
+
+SQUARE_WITH_BASE_NOISE = [
+  [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10],
+  [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
+  [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
+  [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
+  [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
+  [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
+  [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
+  [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
+  [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
+  [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
+  [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
+  [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
+  [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
+  [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
+  [10,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 10],
+  [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
+  
+]
+
+CROSS_WITH_BASE_NOISE = [
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [ 8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8],
+  [ 8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8],
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3],
+  [ 3,  3,  3,  3,  3,  3,  3,  8,  8,  3,  3,  3,  3,  3,  3,  3]
+]
+  

data/examples/patterns_with_noise.rb

@@ -0,0 +1,66 @@
+# 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
+ 
+TRIANGLE_WITH_NOISE = [
+  [ 1,  0,  0,  0,  0,  0,  0,  1,  5,  0,  0,  1,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  3,  0,  1,  9,  9,  1,  0,  0,  0,  0,  3,  0],
+  [ 0,  3,  0,  0,  0,  0,  5,  1,  5,  3,  0,  0,  0,  0,  0,  7],
+  [ 0,  0,  0,  7,  0,  1,  9,  1,  1,  9,  1,  0,  0,  0,  3,  0],
+  [ 0,  0,  0,  0,  0,  3,  5,  0,  3,  5,  5,  0,  0,  0,  0,  0],
+  [ 0,  1,  0,  0,  1,  9,  1,  0,  1,  1,  9,  1,  0,  0,  0,  0],
+  [ 1,  0,  0,  0,  5,  5,  0,  0,  0,  0,  5,  5,  7,  0,  0,  3],
+  [ 0,  0,  3,  3,  9,  1,  0,  0,  1,  0,  1,  9,  1,  0,  0,  0],
+  [ 0,  0,  0,  5,  5,  0,  3,  7,  0,  0,  0,  5,  5,  0,  0,  0],
+  [ 0,  0,  1,  9,  1,  0,  0,  0,  0,  0,  0,  1,  9,  1,  0,  0],
+  [ 0,  0,  5,  5,  0,  0,  0,  0,  3,  0,  0,  0,  5,  5,  0,  0],
+  [ 0,  1,  9,  1,  0,  0,  0,  0,  0,  0,  0,  0,  1,  9,  1,  0],
+  [ 0,  5,  5,  0,  3,  0,  0,  3,  0,  0,  0,  0,  0,  5,  5,  0],
+  [ 1,  9,  1,  0,  0,  3,  0,  0,  0,  1,  0,  0,  0,  1,  9,  1],
+  [ 5,  5,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  5,  5],
+  [10, 10, 10, 10,  1, 10, 10, 10, 10, 10,  1, 10, 10, 10, 10, 10]
+]
+
+SQUARE_WITH_NOISE = [
+  [10,  3, 10, 10, 10,  6, 10, 10, 10, 10, 10,  4, 10, 10, 10, 10],
+  [10,  0,  0,  0,  0,  7,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  3,  0,  0,  0,  0,  7,  0,  6,  1,  0,  0,  0,  0,  0],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  4,  0,  4,  0,  0,  0,  1,  0,  3,  0,  0,  4,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0],
+  [10,  0,  0,  0,  3,  6,  0,  0,  1,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  4,  0,  0,  0,  0,  7,  0,  0, 10],
+  [10,  4,  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  7,  0,  0,  3,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  3,  0,  0,  0,  0,  0,  7, 10],
+  [10,  0,  3,  0,  4,  0,  0,  0,  0,  6,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0, 10],
+  [10,  0,  0,  6,  0,  0,  0,  7,  0,  0,  0,  7,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10, 10, 10, 10,  3, 10, 10, 10, 10,  0, 10, 10,  1, 10,  1, 10]
+  
+]
+
+CROSS_WITH_NOISE = [
+  [ 0,  0,  0,  0,  0,  0,  3,  3,  5,  0,  3,  0,  0,  0,  1,  0],
+  [ 0,  1,  0,  0,  0,  1,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  3,  0,  0,  0],
+  [ 0,  0,  1,  8,  0,  0,  0,  5,  5,  0,  4,  0,  0,  0,  1,  0],
+  [ 0,  0,  0,  0,  0,  3,  0,  5,  0,  0,  0,  0,  1,  0,  0,  0],
+  [ 0,  0,  0,  8,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  1],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  3,  0,  0,  0,  0,  0],
+  [ 5,  5,  5,  8,  5,  3,  5,  5,  5,  5,  5,  5,  5,  5,  0,  5],
+  [ 5,  5,  5,  5,  5,  5,  5,  5,  1,  5,  5,  5,  5,  1,  0,  0],
+  [ 0,  0,  0,  8,  0,  0,  0,  4,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  4,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  4,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 4,  0,  0,  4,  0,  0,  0,  5,  5,  0,  0,  0,  1,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  1,  0,  5,  4,  4,  3,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0, 10,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0]
+]

data/examples/training_patterns.rb

@@ -0,0 +1,68 @@
+# 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
+ 
+
+TRIANGLE = [
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  1,  9,  9,  1,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  5,  5,  5,  5,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  1,  9,  1,  1,  9,  1,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  5,  5,  0,  0,  5,  5,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  1,  9,  1,  0,  0,  1,  9,  1,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0],
+  [ 0,  0,  0,  1,  9,  1,  0,  0,  0,  0,  1,  9,  1,  0,  0,  0],
+  [ 0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0],
+  [ 0,  0,  1,  9,  1,  0,  0,  0,  0,  0,  0,  1,  9,  1,  0,  0],
+  [ 0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0],
+  [ 0,  1,  9,  1,  0,  0,  0,  0,  0,  0,  0,  0,  1,  9,  1,  0],
+  [ 0,  5,  5,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  5,  5,  0],
+  [ 1,  9,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  9,  1],
+  [ 5,  5,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  5,  5],
+  [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
+]
+
+SQUARE = [
+  [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10],
+  [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
+  
+]
+
+CROSS = [
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5],
+  [ 5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0],
+  [ 0,  0,  0,  0,  0,  0,  0,  5,  5,  0,  0,  0,  0,  0,  0,  0]
+]
+  

data/examples/xor.rb

@@ -0,0 +1,28 @@
+# This test was taken from ai4r gem
+
+require File.dirname(__FILE__) + '/../lib/mlp'
+require 'benchmark'
+
+times = Benchmark.measure do
+
+  srand 1
+  
+  a = MLP.new(:hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+
+  3001.times do |i|
+    a.train([0,0], [0])
+    a.train([0,1], [1])
+    a.train([1,0], [1])
+    error = a.train([1,1], [0])
+    puts "Error after iteration #{i}:\t#{error}" if i%200 == 0
+  end
+
+  puts "Test data"
+  puts "[0,0] = > #{a.feed_forward([0,0]).inspect}"
+  puts "[0,1] = > #{a.feed_forward([0,1]).inspect}"
+  puts "[1,0] = > #{a.feed_forward([1,0]).inspect}"
+  puts "[1,1] = > #{a.feed_forward([1,1]).inspect}"
+  
+end
+
+puts "Elapsed time: #{times}"

data/lib/mlp.rb

@@ -0,0 +1,123 @@
+require File.dirname(__FILE__) + '/neuron'
+
+class MLP
+  
+  def initialize(options={})
+    @input_size = options[:inputs]
+    @hidden_layers = options[:hidden_layers]
+    @number_of_output_nodes = options[:output_nodes]
+    setup_network
+  end
+  
+  def feed_forward(input)
+    @network.each_with_index do |layer, layer_index|
+      layer.each do |neuron|
+        if layer_index == 0
+          neuron.fire(input)
+        else
+          input = @network[layer_index-1].map {|x| x.last_output}
+          neuron.fire(input)
+        end
+      end
+    end
+    @network.last.map {|x| x.last_output}
+  end
+  
+  def train(input, targets)
+    # To go back we must go forward
+    feed_forward(input)
+    compute_deltas(targets)
+    update_weights(input)
+    calculate_error(targets)
+  end
+  
+  def inspect
+    @network
+  end
+  
+  private
+  
+  def update_weights(input)
+    reversed_network = @network.reverse
+    reversed_network.each_with_index do |layer, layer_index|
+      if layer_index == 0
+        update_output_weights(layer, layer_index, input)
+      else
+        update_hidden_weights(layer, layer_index, input)
+      end
+    end
+  end
+  
+  def update_output_weights(layer, layer_index, input)
+    inputs = @hidden_layers.empty? ? input : @network[-2].map {|x| x.last_output}
+    layer.each do |neuron|
+      neuron.update_weight(inputs, 0.25)
+    end
+  end
+  
+  def update_hidden_weights(layer, layer_index, original_input)
+    if layer_index == (@network.size - 1)
+      inputs = original_input
+    else
+      inputs = @network.reverse[layer_index+1].map {|x| x.last_output}
+    end
+    layer.each do |neuron|
+      neuron.update_weight(inputs, 0.25)
+    end
+  end
+  
+  def compute_deltas(targets)
+    reversed_network = @network.reverse
+    reversed_network.each_with_index do |layer, layer_index|
+      if layer_index == 0
+        compute_output_deltas(layer, targets)
+      else
+        compute_hidden_deltas(layer, targets)
+      end
+    end
+  end
+  
+  def compute_output_deltas(layer, targets)
+    layer.each_with_index do |neuron, i|
+      output = neuron.last_output
+      neuron.delta = output * (1 - output) * (targets[i] - output)
+    end
+  end
+  
+  def compute_hidden_deltas(layer, targets)
+    layer.each_with_index do |neuron, neuron_index|
+      error = 0
+      @network.last.each do |output_neuron|
+        error += output_neuron.delta * output_neuron.weights[neuron_index]
+      end
+      output = neuron.last_output
+      neuron.delta = output * (1 - output) * error
+    end
+  end
+  
+  def calculate_error(targets)
+    outputs = @network.last.map {|x| x.last_output}
+    sum = 0
+    targets.each_with_index do |t, index|
+      sum += (t - outputs[index]) ** 2
+    end
+    0.5 * sum
+  end
+  
+  def setup_network
+    @network = []
+    # Hidden Layers
+    @hidden_layers.each_with_index do |number_of_neurons, index|
+      layer = []
+      inputs = index == 0 ? @input_size : @hidden_layers[index-1].size
+      number_of_neurons.times { layer << Neuron.new(inputs) }
+      @network << layer
+    end
+    # Output layer
+    inputs = @hidden_layers.empty? ? @input_size : @hidden_layers.last
+    layer = []
+    @number_of_output_nodes.times { layer << Neuron.new(inputs)}
+    @network << layer
+  end
+  
+end

data/lib/neuron.rb

@@ -0,0 +1,51 @@
+class Neuron
+  
+  attr_reader :last_output, :weights
+  attr_accessor :delta
+  
+  def initialize(number_of_inputs)
+    create_weights(number_of_inputs)
+  end
+  
+  def fire(input)
+    @last_output = activation_function(input)
+  end
+  
+  def update_weight(inputs, training_rate)
+    inputs << -1  # Add the bias
+    @weights.each_index do |i|
+      @weights[i] +=  training_rate * delta * inputs[i]
+    end
+  end
+  
+  def inspect
+    @weights
+  end
+  
+  private
+  
+  def activation_function(input)
+    sum = 0
+    input.each_with_index do |n, index|
+#      puts "index:#{index} weight: #{@weights[index]} input: #{n} input_size: #{input.size}"
+      sum +=  @weights[index] * n
+    end
+    sum += @weights.last * -1 #bias node
+    sigmoid_function(sum)
+  end
+  
+  # g(h) = 1 / (1+exp(-B*h(j)))
+  def sigmoid_function(x)
+    1 / (1+Math.exp(-1 * (x)))
+  end
+  
+  def create_weights(number_of_inputs)
+    # Create random weights between 0 & 1
+    # Plus another one for the bias node
+    @weights = []
+    (number_of_inputs + 1).times do
+      @weights << (rand > 0.5 ? -rand : rand)
+    end
+  end
+  
+end

data/mlp.gemspec

@@ -0,0 +1,64 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mlp}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["reddavis"]
+  s.date = %q{2009-09-02}
+  s.description = %q{Multi-Layer Perceptron Neural Network in Ruby}
+  s.email = %q{reddavis@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".autotest",
+     ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "examples/backpropagation_example.rb",
+     "examples/patterns_with_base_noise.rb",
+     "examples/patterns_with_noise.rb",
+     "examples/training_patterns.rb",
+     "examples/xor.rb",
+     "lib/mlp.rb",
+     "lib/neuron.rb",
+     "mlp.gemspec",
+     "test/helper.rb",
+     "test/test_mlp.rb",
+     "test/test_neuron.rb"
+  ]
+  s.homepage = %q{http://github.com/reddavis/mlp}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Multi-Layer Perceptron Neural Network in Ruby}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_mlp.rb",
+     "test/test_neuron.rb",
+     "examples/backpropagation_example.rb",
+     "examples/patterns_with_base_noise.rb",
+     "examples/patterns_with_noise.rb",
+     "examples/training_patterns.rb",
+     "examples/xor.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/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'mlp'
+
+class Test::Unit::TestCase
+end

data/test/test_mlp.rb

@@ -0,0 +1,77 @@
+require 'helper'
+
+class TestMLP < Test::Unit::TestCase
+  
+  should "contain 4 layers" do
+    a = MLP.new(:hidden_layers => [2, 2, 2], :output_nodes => 2, :inputs => 2)
+    assert_equal 4, a.inspect.size
+  end
+  
+  should "create an output neuron with 3 weights" do
+    a = MLP.new(:hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+    assert_equal 3, a.inspect.last.last.weights.size
+  end
+  
+  should "create a hidden neuron with 3 weights" do
+    a = MLP.new(:hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+    assert_equal 3, a.inspect.first.last.weights.size
+  end
+ 
+  should "feed forward and set all neurons last outputs" do
+    a = MLP.new(:hidden_layers => [2], :output_nodes => 2, :inputs => 2)
+    a.feed_forward([0,1])
+    b = a.inspect.inject([]) do |array, n|
+      array << n.map {|x| x.last_output}
+    end
+    b.flatten!
+    assert !b.include?(nil)
+  end
+  
+  should "return an array after feed forward" do
+    a = MLP.new(:hidden_layers => [2], :output_nodes => 2, :inputs => 2)
+    assert_kind_of Array, a.feed_forward([0,1])
+  end
+  
+  should "set its neurons deltas" do
+    a = MLP.new(:hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+    a.train([0,1], [0])
+    b = a.inspect.inject([]) do |array, n|
+      array << n.map {|x| x.delta}
+    end
+    b.flatten!
+    assert !b.include?(nil)
+  end
+  
+  should "update its output neurons weights" do
+    a = MLP.new(:hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+    before = a.inspect.last.first.weights.inject([]) do |array, n|
+      array << n
+    end
+    
+    a.train([0,1], [0])
+    after = a.inspect.last.first.weights.inject([]) do |array, n|
+      array << n
+    end
+    assert_not_equal before, after
+  end
+  
+  should "update its hidden neurons weights" do
+    a = MLP.new(:hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+    before = a.inspect.first.first.weights.inject([]) do |array, n|
+      array << n
+    end
+    
+    a.train([0,1], [0])
+    after = a.inspect.first.first.weights.inject([]) do |array, n|
+      array << n
+    end
+    assert_not_equal before, after
+  end
+  
+  should "return the error (float) after training" do
+    a = MLP.new(:hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+    error = a.train([0,1], [0])
+    assert_kind_of Float, error
+  end
+  
+end

data/test/test_neuron.rb

@@ -0,0 +1,16 @@
+require 'helper'
+
+class TestNeuron < Test::Unit::TestCase
+  
+  should "contain 3 weights (including weight for bias node)" do
+    a = Neuron.new(2)
+    assert_equal 3, a.inspect.size
+  end
+  
+  should "save its last output" do
+    a = Neuron.new(2)
+    a.fire([0,1])
+    assert a.last_output
+  end
+  
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: reddavis-mlp
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- reddavis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-02 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Multi-Layer Perceptron Neural Network in Ruby
+email: reddavis@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .autotest
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- examples/backpropagation_example.rb
+- examples/patterns_with_base_noise.rb
+- examples/patterns_with_noise.rb
+- examples/training_patterns.rb
+- examples/xor.rb
+- lib/mlp.rb
+- lib/neuron.rb
+- mlp.gemspec
+- test/helper.rb
+- test/test_mlp.rb
+- test/test_neuron.rb
+has_rdoc: false
+homepage: http://github.com/reddavis/mlp
+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.2.0
+signing_key: 
+specification_version: 3
+summary: Multi-Layer Perceptron Neural Network in Ruby
+test_files: 
+- test/helper.rb
+- test/test_mlp.rb
+- test/test_neuron.rb
+- examples/backpropagation_example.rb
+- examples/patterns_with_base_noise.rb
+- examples/patterns_with_noise.rb
+- examples/training_patterns.rb
+- examples/xor.rb