db_mlp 0.0.2

data/.autotest

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

data/.gitignore

@@ -0,0 +1,3 @@
+*.rdb
+test_results.txt
+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,51 @@
+= Multi-Layer Perceptron Neural Network
+
+This is a sqlite backed version of my previous MLP.
+
+This version also provides training validation to prevent the MLP from overfitting.
+
+This is first release and because of that it's a bit slow, I'll probably try out using Memcached or something else as its data store.
+
+== Install
+
+  gem sources -a http://gems.github.com
+  sudo gem install reddavis-db_mlp
+
+== How To Use
+
+  require 'rubygems'
+  require 'db_mlp'
+  
+  a = DBMLP.new(path_to_db, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+
+  training = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+  testing = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+  validation = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+  
+  a.train(training, testing, validation, number_of_training_iterations)
+  
+  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}"
+  
+== Test Reports
+
+If you want it to, the MLP can produce a test report. The basic idea is that at the end of training the MLP will feedforward again all the entries that you have passed into the validation attribute. The file contains data about the index, the data that was inputted, the target, the result and the error. Here's an example:
+
+  ID: 0	Attributes: [0, 0]	Target: 0	Resuts: 0.387170168937349	Error: 0.0749503698574878	
+  ID: 1	Attributes: [0, 1]	Target: 1	Resuts: 0.365112645315455	Error: 0.20154097656917	
+  ID: 2	Attributes: [1, 0]	Target: 1	Resuts: 0.40477576498281	Error: 0.1771459449759	
+  ID: 3	Attributes: [1, 1]	Target: 0	Resuts: 0.382819699838249	Error: 0.0732754612921235	
+
+== Benchmarks
+
+  The above example produces these times (3000 iterations)
+  
+                  user     system      total        real
+  DBMLP        9.460000   0.150000   9.610000 ( 10.322743)
+
+== 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 = "db_mlp"
+    gem.summary = %Q{Database backed Multi-Layer Perceptron Neural Network in Ruby}
+    gem.description = %Q{Database backed Multi-Layer Perceptron Neural Network in Ruby}
+    gem.email = "reddavis@gmail.com"
+    gem.homepage = "http://github.com/reddavis/dbmlp"
+    gem.authors = ["reddavis"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+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.2

data/benchmarks/mlp_benchmark.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'benchmarker'
+require 'benchmark'
+require File.dirname(__FILE__) + '/../lib/db_mlp'
+
+Benchmarker.go('lib') do
+  
+  db = "sqlite3://#{File.dirname(File.expand_path(__FILE__))}/data.rdb"
+  
+
+  training = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+  testing = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+  validation = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+  
+  Benchmark.bm do |x|
+    x.report do
+      a = DBMLP.new(db, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+      a.train(training, testing, validation, 10)
+    end
+  end
+
+end

data/db_mlp.gemspec

@@ -0,0 +1,69 @@
+# 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{db_mlp}
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["reddavis"]
+  s.date = %q{2009-10-12}
+  s.description = %q{Database backed Multi-Layer Perceptron Neural Network in Ruby}
+  s.email = %q{reddavis@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".autotest",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "benchmarks/data.rdb",
+     "benchmarks/mlp_benchmark.rb",
+     "db_mlp.gemspec",
+     "examples/backpropagation_example.rb",
+     "examples/data.rdb",
+     "examples/patterns_with_base_noise.rb",
+     "examples/patterns_with_noise.rb",
+     "examples/training_patterns.rb",
+     "examples/xor.rb",
+     "lib/db_mlp.rb",
+     "lib/models/neuron.rb",
+     "lib/modules/create_test_results.rb",
+     "lib/modules/db.rb",
+     "lib/modules/training.rb",
+     "profiling/profile.rb",
+     "test/db/test.txt",
+     "test/helper.rb",
+     "test/test_db_mlp.rb"
+  ]
+  s.homepage = %q{http://github.com/reddavis/dbmlp}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Database backed Multi-Layer Perceptron Neural Network in Ruby}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_db_mlp.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/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,25 @@
+require File.dirname(__FILE__) + '/../lib/db_mlp'
+require 'benchmark'
+
+db = "sqlite3://#{File.dirname(File.expand_path(__FILE__))}/data.rdb"
+a = DBMLP.new(db, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+
+times = Benchmark.measure do
+
+  srand 1
+  
+  training = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+  testing = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+  validation = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+  
+  a.train(training, testing, validation, 3001)
+  
+  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/db_mlp.rb

@@ -0,0 +1,55 @@
+#require 'rubygems'
+require 'datamapper'
+require File.expand_path(File.dirname(__FILE__) + '/models/neuron')
+require File.expand_path(File.dirname(__FILE__) + '/modules/create_test_results')
+require File.expand_path(File.dirname(__FILE__) + '/modules/db')
+require File.expand_path(File.dirname(__FILE__) + '/modules/training')
+
+class DBMLP
+  include DB
+  include Training
+  include CreateTestResults
+    
+  def initialize(db_path, options={})
+    @input_size = options[:inputs]
+    @hidden_layers = options[:hidden_layers]
+    @number_of_output_nodes = options[:output_nodes]
+    @verbose = options[:verbose] || false
+    connect_to_db(db_path)
+    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(training, testing, validations, n=3000, report_path=nil)
+    train_and_cross_validate(training, validations, n)
+    create_test_report(testing, report_path) unless report_path.nil?
+  end
+  
+  def inspect
+    @network
+  end
+  
+  private
+  
+  def last_outputs
+    @network.last.map {|x| x.last_output}
+  end
+  
+  def print_message(message)
+    puts message if @verbose
+  end
+  
+end

data/lib/models/neuron.rb

@@ -0,0 +1,62 @@
+class Neuron
+  include DataMapper::Resource
+  property :id, Serial
+  property :layer_index, Integer, :index => true
+  property :last_output, Float
+  property :db_weights, String
+  property :delta, Float
+  
+  def initialize(number_of_inputs, layer_index)
+    create_weights(number_of_inputs)
+    self.layer_index = layer_index
+  end
+  
+  def fire(input)
+    self.last_output = activation_function(input)
+  end
+  
+  def update_weight(inputs, training_rate)
+    inputs << -1  # Add the bias
+    new_weights = weights
+    weights.each_index do |i|
+      new_weights[i] +=  training_rate * delta * inputs[i]
+    end
+    self.db_weights = new_weights.join(',')
+  end
+  
+  def inspect
+    weights
+  end
+  
+  def weights
+    db_weights.split(',').map {|x| x.to_f}
+  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
+    self.db_weights = weights.join(',')
+  end
+  
+end

data/lib/modules/create_test_results.rb

@@ -0,0 +1,32 @@
+module CreateTestResults
+  
+  private
+  
+  def create_test_report(test_examples, report_path)
+    results = []
+    
+    test_examples.each_with_index do |example, index|
+      input, target = example[0], example[1]
+      feed_forward(input)
+      info = "ID: #{index}\tAttributes: #{input.inspect}\tTarget: #{target.inspect}\tResuts: #{last_outputs.inspect}\tError: #{calculate_error(target)}\t"
+      results << info
+    end
+    
+    File.open(report_path, "w+") do |file|
+      results.each do |line|
+        file.write(line)
+        file.write("\n")
+      end
+    end
+  end
+  
+  def calculate_error(targets)
+    outputs = last_outputs
+    sum = 0
+    targets.each_with_index do |t, index|
+      sum += (t - outputs[index]) ** 2
+    end
+    0.5 * sum
+  end
+  
+end

data/lib/modules/db.rb

@@ -0,0 +1,67 @@
+module DB
+  
+  private
+  
+  def setup_network
+    @network = []
+    if new_mlp?
+      wipe_db!      
+      # 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, index) }
+        @network << layer
+        layer.each {|x| x.save!}
+      end
+      # Output layer
+      inputs = @hidden_layers.empty? ? @input_size : @hidden_layers.last
+      layer = []
+      @number_of_output_nodes.times { layer << Neuron.new(inputs, -1)}
+      @network << layer
+      layer.each {|x| x.save!}
+    else
+      # Problematic area???
+      @hidden_layers.each_index do |index|
+        layer = Neuron.all(:layer_index => index, :order => [:id.asc])
+        @network << layer
+      end
+      layer = Neuron.all(:layer_index => -1, :order => [:id.asc])
+      @network << layer
+    end
+  end
+
+  def wipe_db!
+    DataMapper.auto_migrate!
+  end
+
+  # Only one mlp per DB, so if this mlp's shape is diff
+  # to whats in the db then we empty and create a new one
+  # if its the same then we carry on as we left off
+  def new_mlp?
+    new_mlp = false
+    # Check hidden_layers
+    @hidden_layers.each_index do |i|
+      if Neuron.count(:layer_index => i) != @hidden_layers[i]
+        new_mlp = true
+      end
+    end
+    # Check output layer
+    if Neuron.count(:layer_index => -1) != @number_of_output_nodes
+      new_mlp = true
+    end
+
+    if Neuron.count != (@hidden_layers.size + 1)
+      new_mlp = true
+    end
+    new_mlp
+  end
+
+  def connect_to_db(db_path)
+#    DataMapper::Logger.new(STDOUT, :debug)
+#    DataObjects::Sqlite3.logger = DataObjects::Logger.new(STDOUT, 0)
+    DataMapper.setup(:default, db_path)
+    DataMapper.auto_upgrade!
+  end
+  
+end

data/lib/modules/training.rb

@@ -0,0 +1,108 @@
+module Training
+  
+  private
+  
+  def train_and_cross_validate(training, validations, n)
+    errors = []
+    1.upto(n) do |i|
+      if i % 200 == 0
+        if validate(validations)
+          print_message("Stopping at #{i}")
+          break
+        end
+      end
+      print_message("Iteration #{i}/#{n}")
+      training = training.sort_by { rand } #shaken or stirred?
+      training.each do |t|
+        input, target = t[0], t[1]
+        training_process(input, target)
+      end
+    end
+    save_all_neurons
+  end
+  
+  def validate(validations)
+    @validations ||= []
+    sum = 0
+    validations.each do |v|
+      input, target = v[0], v[1]
+      feed_forward(input)
+      sum += calculate_error(target)
+    end
+    @validations << sum
+    return false if @validations.size < 2
+    @validations[-1] > @validations[-2] ? true : false
+  end
+  
+  def training_process(input, targets)
+    # To go back we must go forward
+    feed_forward(input)
+    compute_deltas(targets)
+    update_weights(input)
+  end
+  
+  def save_all_neurons
+    @network.each do |layer|
+      layer.each {|n| n.save!}
+    end
+  end
+  
+  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.clone
+    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
+  
+end

data/profiling/profile.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../lib/db_mlp'
+require 'rubygems'
+require 'ruby-prof'
+
+db = "sqlite3://#{File.dirname(File.expand_path(__FILE__))}/../benchmarks/data.rdb"
+
+a = DBMLP.new(db, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+
+@training = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+@testing = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+@validation = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+
+result = RubyProf.profile do
+  a = a.train(@training, @testing, @validation, 100)
+end
+
+printer = RubyProf::FlatPrinter.new(result)
+printer.print(STDOUT, 0)

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 'db_mlp'
+
+class Test::Unit::TestCase
+end

data/test/test_db_mlp.rb

@@ -0,0 +1,151 @@
+require 'helper'
+
+class TestDBMLP < Test::Unit::TestCase
+  context "Testing Report" do
+    setup do
+      set_data_variables
+      db_path = "sqlite3://#{File.dirname(File.expand_path(__FILE__))}/db/data.rdb"
+      @test_results_path = File.dirname(File.expand_path(__FILE__)) + '/db/test_results.txt'
+      a = DBMLP.new(db_path, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+      a.train(@training, @testing, @validation, 1, @test_results_path)
+    end
+    
+    should "create a test results .txt file" do
+      assert File.exists?(@test_results_path)
+    end
+    
+    should "contain some text" do
+      File.open(@test_results_path, 'r+') do |file|
+        assert !file.readlines.empty?
+      end
+    end
+  end
+  
+  context "DBMLP Instance" do
+    setup do
+      set_data_variables
+      @db_path = "sqlite3://#{File.dirname(File.expand_path(__FILE__))}/db/data.rdb"
+    end
+  
+    should "contain 4 layers" do
+      a = DBMLP.new(@db_path, :hidden_layers => [2, 2, 2], :output_nodes => 2, :inputs => 2)
+      assert_equal 4, a.inspect.size
+    end
+    
+    should "contain saved 3 layers" do
+      DBMLP.new(@db_path, :hidden_layers => [2, 2], :output_nodes => 2, :inputs => 2)
+      b = Neuron.all.map {|x| x.layer_index}.uniq.size
+      assert_equal 3, b
+    end
+    
+    should "contain 1 output node" do
+      DBMLP.new(@db_path, :hidden_layers => [2], :output_nodes =>4, :inputs => 2)
+      a = DBMLP.new(@db_path, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+      assert_equal 1, a.inspect.last.size
+    end
+
+    should "feed forward and set all neurons last outputs" do
+      a = DBMLP.new(@db_path, :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 = DBMLP.new(@db_path, :hidden_layers => [2], :output_nodes => 2, :inputs => 2)
+      assert_kind_of Array, a.feed_forward([0,1])
+    end
+  
+    should "save its neurons deltas" do
+      a = DBMLP.new(@db_path, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+      a.train(@training, @testing, @validation, 1)
+      b = Neuron.all(:delta.not => nil)
+      assert !b.empty?
+    end
+  
+    should "save its output neurons weights" do
+      a = DBMLP.new(@db_path, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+      before = Neuron.first(:layer_index => -1).weights.inject([]) do |array, n|
+        array << n
+      end
+    
+      a.train(@training, @testing, @validation, 1)
+      
+      after = Neuron.first(:layer_index => -1).weights.inject([]) do |array, n|
+        array << n
+      end
+      assert_not_equal before, after
+    end
+  
+    should "update its hidden neurons weights" do
+      a = DBMLP.new(@db_path, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+      before = Neuron.first(:layer_index => 0).weights.inject([]) do |array, n|
+        array << n
+      end
+    
+      a.train(@training, @testing, @validation, 1)
+      after = Neuron.first(:layer_index => 0).weights.inject([]) do |array, n|
+        array << n
+      end
+      assert_not_equal before, after
+    end
+  end
+    
+  context "DB for a new mlp" do
+    setup do
+      db_path = "sqlite3://#{File.dirname(File.expand_path(__FILE__))}/db/data.rdb"
+      @a = DBMLP.new(db_path, :hidden_layers => [2, 2], :output_nodes => 2, :inputs => 2)
+    end
+  
+    should "save 6 neurons" do
+      assert_equal 6, Neuron.count
+    end
+    
+    should "save 2 hidden neurons in the first hidden layer" do
+      assert_equal 2, Neuron.count(:layer_index => 0)
+    end
+  end
+
+  context "Neuron" do
+    setup do
+      @db_path = "sqlite3://#{File.dirname(File.expand_path(__FILE__))}/db/data.rdb"
+    end
+  
+    should "have 2 weights on output neuron" do
+      a = DBMLP.new(@db_path, :hidden_layers => [1], :output_nodes => 1, :inputs => 2)
+      assert_equal 2, a.inspect.last.last.weights.size
+    end
+    
+    should "have saved 2 weights on output neuron" do
+      a = DBMLP.new(@db_path, :hidden_layers => [1], :output_nodes => 1, :inputs => 2)
+      assert_equal 2, Neuron.first(:layer_index => -1).weights.size
+    end
+    
+    should "have 3 weights on output neuron" do
+      a = DBMLP.new(@db_path, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+      assert_equal 3, a.inspect.last.last.weights.size
+    end
+    
+    should "have saved 3 weights on output neuron" do
+      a = DBMLP.new(@db_path, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+      assert_equal 3, Neuron.first(:layer_index => -1).weights.size
+    end
+    
+    should "create a hidden neuron with 3 weights" do
+      a = DBMLP.new(@db_path, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+      assert_equal 3, a.inspect.first.last.weights.size
+    end
+  end
+  
+  private
+  
+  def set_data_variables
+    @training = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+    @testing = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+    @validation = [[[0,0], [0]], [[0,1], [1]], [[1,0], [1]], [[1,1], [0]]]
+  end
+
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: db_mlp
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- reddavis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-12 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Database backed Multi-Layer Perceptron Neural Network in Ruby
+email: reddavis@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .autotest
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- benchmarks/data.rdb
+- benchmarks/mlp_benchmark.rb
+- db_mlp.gemspec
+- examples/backpropagation_example.rb
+- examples/data.rdb
+- examples/patterns_with_base_noise.rb
+- examples/patterns_with_noise.rb
+- examples/training_patterns.rb
+- examples/xor.rb
+- lib/db_mlp.rb
+- lib/models/neuron.rb
+- lib/modules/create_test_results.rb
+- lib/modules/db.rb
+- lib/modules/training.rb
+- profiling/profile.rb
+- test/db/test.txt
+- test/helper.rb
+- test/test_db_mlp.rb
+has_rdoc: true
+homepage: http://github.com/reddavis/dbmlp
+licenses: []
+
+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.3.5
+signing_key: 
+specification_version: 3
+summary: Database backed Multi-Layer Perceptron Neural Network in Ruby
+test_files: 
+- test/helper.rb
+- test/test_db_mlp.rb
+- examples/backpropagation_example.rb
+- examples/patterns_with_base_noise.rb
+- examples/patterns_with_noise.rb
+- examples/training_patterns.rb
+- examples/xor.rb