db_mlp 0.0.7 → 0.0.8

data/README.rdoc

@@ -1,10 +1,8 @@
 = Multi-Layer Perceptron Neural Network
 
-This is a sqlite backed version of my previous MLP.
+This is a Multi-Layer Perceptron Neural Network that uses early stopping to prevent itself from overfitting.
 
-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.
+It also saves its state so that you can train the network and then re-use it again when-ever you want.
 
 == Install
 
@@ -15,13 +13,13 @@ This is first release and because of that it's a bit slow, I'll probably try out
 
   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"
@@ -30,7 +28,13 @@ This is first release and because of that it's a bit slow, I'll probably try out
   puts "[1,0] = > #{a.feed_forward([1,0]).inspect}"
   puts "[1,1] = > #{a.feed_forward([1,1]).inspect}"
   
-You can also tell the network what iterations you would like it to perform validation on:
+After training has finished the network is saved to the file path specified. When you want to re-use the network just call:
+
+  a = DBMLP.load(path_to_db)
+
+  a.feed_for_forward([0,1])
+  
+You can also tell the network what iterations you would like it to perform validations on:
 
   DBMLP.new(path_to_db, :hidden_layers => [2], 
                         :output_nodes => 1, 
@@ -51,7 +55,7 @@ If you want it to, the MLP can produce a test report. The basic idea is that at
   The above example produces these times (3000 iterations)
   
                   user     system      total        real
-  DBMLP        9.460000   0.150000   9.610000 ( 10.322743)
+  DBMLP        0.870000   0.000000   0.870000    (0.877338)
 
 == Copyright
 

data/VERSION

@@ -1 +1 @@
-0.0.7
+0.0.8

data/benchmarks/mlp_benchmark.rb

@@ -1,22 +1,15 @@
-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"
   
+db = File.dirname(File.expand_path(__FILE__)) + "/data.txt"
 
-  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
+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
+Benchmark.bm do |x|
+  x.report do
+    a = DBMLP.new(db, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+    a.train(training, testing, validation, 3000)
+  end
+end

data/db_mlp.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{db_mlp}
-  s.version = "0.0.7"
+  s.version = "0.0.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["reddavis"]
-  s.date = %q{2009-11-11}
+  s.date = %q{2010-01-05}
   s.description = %q{Database backed Multi-Layer Perceptron Neural Network in Ruby}
   s.email = %q{reddavis@gmail.com}
   s.extra_rdoc_files = [
@@ -23,26 +23,27 @@ Gem::Specification.new do |s|
      "README.rdoc",
      "Rakefile",
      "VERSION",
-     "benchmarks/data.rdb",
+     "benchmarks/data.txt",
      "benchmarks/mlp_benchmark.rb",
      "db_mlp.gemspec",
      "examples/backpropagation_example.rb",
      "examples/data.rdb",
+     "examples/data.txt",
      "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/test_results_parser.rb",
-     "lib/modules/training.rb",
+     "lib/db_mlp/network.rb",
+     "lib/db_mlp/neuron.rb",
+     "lib/db_mlp/test_results.rb",
+     "lib/db_mlp/test_results_parser.rb",
+     "lib/db_mlp/training.rb",
      "profiling/profile.rb",
-     "test/db/test.txt",
-     "test/db/test_results_test/results.txt",
+     "test/db/db.txt",
      "test/helper.rb",
-     "test/test_db_mlp.rb"
+     "test/test_db_mlp.rb",
+     "test/test_neuron.rb"
   ]
   s.homepage = %q{http://github.com/reddavis/dbmlp}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -52,6 +53,7 @@ Gem::Specification.new do |s|
   s.test_files = [
     "test/helper.rb",
      "test/test_db_mlp.rb",
+     "test/test_neuron.rb",
      "examples/backpropagation_example.rb",
      "examples/patterns_with_base_noise.rb",
      "examples/patterns_with_noise.rb",

data/examples/xor.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/../lib/db_mlp')
 require 'benchmark'
 
-db = "sqlite3://#{File.dirname(File.expand_path(__FILE__))}/data.rdb"
+db = File.dirname(File.expand_path(__FILE__)) + "/data.txt"
 a = DBMLP.new(db, :hidden_layers => [2], 
                   :output_nodes => 1, 
                   :inputs => 2,

data/lib/db_mlp.rb

@@ -1,29 +1,42 @@
-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')
-require File.expand_path(File.dirname(__FILE__) + '/modules/test_results_parser')
+require File.expand_path(File.dirname(__FILE__) + '/db_mlp/neuron')
+require File.expand_path(File.dirname(__FILE__) + '/db_mlp/test_results')
+require File.expand_path(File.dirname(__FILE__) + '/db_mlp/training')
+require File.expand_path(File.dirname(__FILE__) + '/db_mlp/test_results_parser')
+require File.expand_path(File.dirname(__FILE__) + '/db_mlp/network')
 
 class DBMLP
-  include DB
+  include Network
   include Training
-  include CreateTestResults
+  include TestResults
   include TestResultsParser
-    
+  
+  class << self
+    def load(db_path)
+      data = ""
+      File.open(db_path) do |f|
+        while line = f.gets
+          data << line
+        end
+      end
+      Marshal.load(data)
+    end
+  end
+  
   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
+    @output_nodes = options[:output_nodes]
+    @verbose = options[:verbose]
     @validate_every = options[:validate_every] || 200
-    connect_to_db(db_path)
-    setup_network
+    @db_path = db_path
+        
+    @network = setup_network
   end
   
   def feed_forward(input)
     @network.each_with_index do |layer, layer_index|
+      # We go through each layer taking the previous layers outputs and using them
+      # as the next layers inputs
       layer.each do |neuron|
         if layer_index == 0
           neuron.fire(input)
@@ -33,18 +46,26 @@ class DBMLP
         end
       end
     end
-    @network.last.map {|x| x.last_output}
+    last_outputs
   end
   
   def train(training, testing, validations, n=3000, report_path=nil)
     train_and_cross_validate(training, validations, n)
+    # Create a test report if they want one
     create_test_report(testing, report_path) unless report_path.nil?
+    save
   end
   
   def inspect
     @network
   end
   
+  def save
+    File.open(@db_path, 'w+') do |f|
+      f.write(Marshal.dump(self))
+    end
+  end
+      
   private
   
   def last_outputs

data/lib/db_mlp/network.rb

@@ -0,0 +1,32 @@
+module Network
+  private
+  
+  # Creates a network from left to right (output nodes on the right)
+  def setup_network
+    hidden_layers << output_layer
+  end
+  
+  def hidden_layers
+    network = []
+    @hidden_layers.each_with_index do |neurons, index|
+      # Number of inputs
+      if index == 0
+        inputs = @input_size
+      else
+        inputs = network.last.size
+      end
+      
+      layer = []
+      neurons.times { layer << Neuron.new(inputs, index) }
+      network << layer
+    end
+    network
+  end
+  
+  def output_layer
+    nodes = []
+    inputs = @hidden_layers.last
+    @output_nodes.times {|n| nodes << Neuron.new(inputs, n) }
+    nodes
+  end
+end

data/lib/{models → db_mlp}/neuron.rb

@@ -1,27 +1,24 @@
 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
+  
+  attr_accessor :delta
+  
+  attr_reader :layer_index, :last_output
   
   def initialize(number_of_inputs, layer_index)
     create_weights(number_of_inputs)
-    self.layer_index = layer_index
+    @layer_index = layer_index
   end
   
   def fire(input)
-    self.last_output = activation_function(input)
+    @last_output = activation_function(input)
   end
   
   def update_weight(inputs, training_rate)
-    inputs << -1  # Add the bias
-    new_weights = weights
+    inputs << -1  # Add the bias node
+        
     weights.each_index do |i|
-      new_weights[i] +=  training_rate * delta * inputs[i]
+      weights[i] +=  training_rate * delta * inputs[i]
     end
-    self.db_weights = new_weights.join(',')
   end
   
   def inspect
@@ -29,7 +26,7 @@ class Neuron
   end
   
   def weights
-    db_weights.split(',').map {|x| x.to_f}
+    @weights ||= []
   end
   
   private
@@ -37,7 +34,6 @@ class Neuron
   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
@@ -50,13 +46,11 @@ class Neuron
   end
   
   def create_weights(number_of_inputs)
-    # Create random weights between 0 & 1
+    # Create random weights between -1 & 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 → db_mlp/test_results.rb}

@@ -1,7 +1,8 @@
-module CreateTestResults
+module TestResults
   
   private
   
+  # Create a tab seperated file
   def create_test_report(test_examples, report_path)
     results = []
     results << "ID\tAttributes\tTarget\tResults\tError" # Add the headers
@@ -21,6 +22,7 @@ module CreateTestResults
     end
   end
   
+  # Calculates sum-of-squares error
   def calculate_error(targets)
     outputs = last_outputs
     sum = 0

data/lib/{modules → db_mlp}/test_results_parser.rb

@@ -5,6 +5,9 @@ module TestResultsParser
   
   module Parser
     
+    # This goes through the test results file created by calling
+    # #create_test_report. It then tells you how accurate the 
+    # classification has been on the testing data.
     def parse_test_results(filepath, error_limit=0.05)
       total, correct = 0.0, 0.0
       File.open(filepath) do |f|

data/lib/{modules → db_mlp}/training.rb

@@ -3,36 +3,44 @@ module Training
   private
   
   def train_and_cross_validate(training, validations, n)
-    errors = []
     1.upto(n) do |i|
       if i % @validate_every == 0
         print_message("Validating at #{i}")
-        if validate(validations)
+        
+        if validates?(validations)
           print_message("Stopping at #{i}")
           break
         end
       end
+      
       print_message("Iteration #{i}/#{n}")
-      training = training.sort_by { rand } #shaken or stirred?
+      
+      # Move the training data around a bit
+      training = training.sort_by { rand }
+      
       training.each do |t|
         input, target = t[0], t[1]
         training_process(input, target)
       end
-    end
-    save_all_neurons
+    end #1.upto
   end
   
-  def validate(validations)
-    @validations ||= []
-    sum = 0
+  # We are checking if the error has increased since we last checked
+  # If it is we should probably stop training as we dont want to overfit the data
+  def validates?(validations)
+    validation = 0
+    
     validations.each do |v|
       input, target = v[0], v[1]
       feed_forward(input)
-      sum += calculate_error(target)
+      validation += calculate_error(target)
+    end
+    
+    if @last_validation.nil? || (validation > @last_validation)
+      false
+    else
+      true
     end
-    @validations << sum
-    return false if @validations.size < 2
-    @validations[-1] > @validations[-2] ? true : false
   end
   
   def training_process(input, targets)
@@ -42,12 +50,6 @@ module Training
     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|
@@ -60,6 +62,8 @@ module Training
   end
   
   def update_output_weights(layer, layer_index, input)
+    # If we have no hidden layer, just use the input, otherwise take
+    # the outputs of the last hidden layer
     inputs = @hidden_layers.empty? ? input : @network[-2].map {|x| x.last_output}
     layer.each do |neuron|
       neuron.update_weight(inputs, 0.25)
@@ -67,8 +71,10 @@ module Training
   end
   
   def update_hidden_weights(layer, layer_index, original_input)
+    # If we're on the first hidden layer, we want to use the inputs from the input
     if layer_index == (@network.size - 1)
       inputs = original_input.clone
+    # Or we want to use the inputs from the outputs of the previous layer
     else
       inputs = @network.reverse[layer_index+1].map {|x| x.last_output}
     end
@@ -98,8 +104,8 @@ module Training
   def compute_hidden_deltas(layer, targets, previous_layer)
     layer.each_with_index do |neuron, neuron_index|
       error = 0
-      previous_layer.each do |output_neuron|
-        error += output_neuron.delta * output_neuron.weights[neuron_index]
+      previous_layer.each do |previous_layer_neuron|
+        error += previous_layer_neuron.delta * previous_layer_neuron.weights[neuron_index]
       end
       output = neuron.last_output
       neuron.delta = output * (1 - output) * error

data/profiling/profile.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/../lib/db_mlp'
 require 'rubygems'
 require 'ruby-prof'
 
-db = "sqlite3://#{File.dirname(File.expand_path(__FILE__))}/../benchmarks/data.rdb"
+db = File.dirname(File.expand_path(__FILE__)) + "/../benchmarks/data.txt"
 
 a = DBMLP.new(db, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
 

data/test/test_db_mlp.rb

@@ -1,45 +1,18 @@
 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
-  
+class TestDBMLP < Test::Unit::TestCase  
   context "DBMLP Instance" do
     setup do
       set_data_variables
-      @db_path = "sqlite3://#{File.dirname(File.expand_path(__FILE__))}/db/data.rdb"
+      @db_path = saved_db_path
     end
         
-    should "contain 4 layers" do
+    should "contain 4 layers (including output layer)" 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
@@ -59,91 +32,34 @@ class TestDBMLP < Test::Unit::TestCase
       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
+    should "set its neurons deltas" 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
+      b = a.inspect.flatten.map {|x| x.delta}.delete_if {|x| !x.nil?}
+      assert b.empty?
     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
+  context "Network Structure" do
     setup do
-      @db_path = "sqlite3://#{File.dirname(File.expand_path(__FILE__))}/db/data.rdb"
+      @db_path = saved_db_path
     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
+    should "have saved 2 neurons on the first hidden layer" 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
+      assert_equal 2, a.inspect[0].size
     end
   end
   
   context "Validations" do
     setup do
       $stdout = StringIO.new
-      @db_path = "sqlite3://#{File.dirname(File.expand_path(__FILE__))}/db/data.rdb"
+      @db_path = saved_db_path
       set_data_variables 
     end
     
@@ -159,25 +75,61 @@ class TestDBMLP < Test::Unit::TestCase
       assert_equal 2, output.size
     end
   end
-
-   context "Testing Results Parser" do
-     setup do
-       @test_results = File.dirname(__FILE__) + '/db/test_results_test/results.txt'
-     end
-
-     should "return 100%" do
-       result = DBMLP.parse_test_results(@test_results, 1)
-       assert_equal 100, result
-     end
-
-     should "return 50%" do
-       result = DBMLP.parse_test_results(@test_results, 0.00002)
-       assert_equal 50, result
-     end
-   end
+  
+  context "Testing Report" do
+    setup do
+      set_data_variables
+      db_path = saved_db_path
+      @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 "IO" do
+    context "Save" do
+      setup do
+        db_path = saved_db_path
+        FileUtils.rm(db_path, :force => true)
+        @a = DBMLP.new(db_path, :hidden_layers => [2], :output_nodes => 1, :inputs => 2)
+      end
+    
+      should "create a file" do
+        @a.save
+        assert File.exists?(saved_db_path)
+      end
+    end
+    
+    context "Load" do
+      setup do
+        @db_path = saved_db_path
+        FileUtils.rm(@db_path, :force => true)
+        DBMLP.new(@db_path, :hidden_layers => [8], :output_nodes => 1, :inputs => 2).save
+      end
+    
+      should "create a file" do
+        a = DBMLP.load(@db_path)
+        assert_equal 8, a.inspect[0].size
+      end
+    end
+  end
    
   private
   
+  def saved_db_path
+    File.expand_path(File.dirname(__FILE__) + '/db/db.txt')
+  end
+  
   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]]]

data/test/test_neuron.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+class TestNeuron < Test::Unit::TestCase  
+  context "Initialization" do
+    should "set initial weights" do
+      a = create_neuron
+      assert !a.weights.empty?
+      assert_equal 4, a.weights.size  # + Bias node
+    end
+  end
+  
+  context "Weight Update" do
+    should "change the weight of the neuron" do
+      a = create_neuron
+      before = a.weights.clone
+      a.delta = 0.9
+      a.update_weight([1,2,3], 0.5)
+      assert_not_equal before, a.weights
+    end
+  end
+  
+  context "Fire" do
+    should "change last_output" do
+      a = create_neuron
+      a.fire([1,2,3])
+      assert a.last_output
+    end
+  end
+  
+  private
+  
+  def create_neuron(weights=3, layer_index=0)
+    Neuron.new(weights, layer_index)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: db_mlp
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors: 
 - reddavis
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-11 00:00:00 +00:00
+date: 2010-01-05 00:00:00 +00:00
 default_executable: 
 dependencies: []
 
@@ -29,26 +29,27 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
-- benchmarks/data.rdb
+- benchmarks/data.txt
 - benchmarks/mlp_benchmark.rb
 - db_mlp.gemspec
 - examples/backpropagation_example.rb
 - examples/data.rdb
+- examples/data.txt
 - 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/test_results_parser.rb
-- lib/modules/training.rb
+- lib/db_mlp/network.rb
+- lib/db_mlp/neuron.rb
+- lib/db_mlp/test_results.rb
+- lib/db_mlp/test_results_parser.rb
+- lib/db_mlp/training.rb
 - profiling/profile.rb
-- test/db/test.txt
-- test/db/test_results_test/results.txt
+- test/db/db.txt
 - test/helper.rb
 - test/test_db_mlp.rb
+- test/test_neuron.rb
 has_rdoc: true
 homepage: http://github.com/reddavis/dbmlp
 licenses: []
@@ -80,6 +81,7 @@ summary: Database backed Multi-Layer Perceptron Neural Network in Ruby
 test_files: 
 - test/helper.rb
 - test/test_db_mlp.rb
+- test/test_neuron.rb
 - examples/backpropagation_example.rb
 - examples/patterns_with_base_noise.rb
 - examples/patterns_with_noise.rb

data/lib/modules/db.rb

@@ -1,67 +0,0 @@
-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/test/db/test_results_test/results.txt

@@ -1,5 +0,0 @@
-ID	Attributes	Target	Results	Error
-0	[0, 0]	[0]	[0.685402162886773]	0.001
-1	[0, 1]	[1]	[0.682897049007785]	0.00002
-2	[1, 0]	[1]	[0.675313520548373]	0.00001235
-3	[1, 1]	[0]	[0.673899630689015]	0.00000000009