hopfield 1.2 → 1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f1e7bbc674b32b5f95647dcb42109ce6a37bc0b
-  data.tar.gz: 083b4ff167702baf75a0dd050e3fd75de42f1c97
+  metadata.gz: eb3940e29051c8015264955b03947a57aca274bf
+  data.tar.gz: 52ad2e0455663abb7d345391d31383bad489daf9
 SHA512:
-  metadata.gz: 110a161f19c05846bde6fa84d4775af490ec44c7c3352b71338ca4c436ce793ac3b27b09e410fc70b85b1337c33c15f59fd9eefd85c339b9a99c57032d1aebd3
-  data.tar.gz: 56c9fb943f7be0e5d23983c5db41e8739b1c10118252828bfa9a21f40af5d42cf69aa59ae1437d28bd70e426b2bbb1e2aa7224dc7d51470345f46544a4d47759
+  metadata.gz: 0bf65127ea952843e26c0089e7f1e0eae112b336382b5e106726779f09d723312905e19d0add3971f6ce5e751c132302a5062e904dc645baa6e4ebb554a30aab
+  data.tar.gz: 8eaa5500db84c1891bded3e90035697782c6e610655a9ebad241d04af136f6e61ed9b14fec4fa961afcc15c1332486973241a89a02f299cd79bf569870b756bc

data/README.md

@@ -1,6 +1,6 @@
 # Hopfield Network in Ruby
 
-A pure, albeit slow Ruby implementation of a Hopfield Network.
+A short and simple Ruby implementation of a Hopfield Network. Includes a small C extension to speed up the CPU intensive loops.
 
 ## What is it?
 [Hopfield Networks](http://en.wikipedia.org/wiki/Hopfield_network) model the way humans recall memories, or more specific, how neurons recall the pattern. This means you first train the network with a set of known patterns and then pass an unknown or perturbed version of the pattern. The neurons will restore the missing information to create an exact match. 

data/ext/hopfield/hopfield.c

@@ -38,10 +38,65 @@ static VALUE hopfield_calculate_weights_hebbian(VALUE self, VALUE patterns, VALU
   return weights;
 }
 
+static VALUE hopfield_transfer_activation(float activation) {
+  return INT2FIX((activation >= 0) ? 1 : -1);
+}
+
+static VALUE hopfield_calculate_neuron_state(VALUE self, VALUE neuron_index, VALUE neurons, VALUE weights) {
+  Check_Type(neuron_index, T_FIXNUM);
+  Check_Type(neurons, T_ARRAY);
+  Check_Type(weights, T_ARRAY);
+  
+  float activation = 0.0;
+  int i = FIX2INT(neuron_index);
+  int neurons_count = (int) RARRAY_LEN(neurons);
+  
+  for(int j = 0; j < neurons_count; j++) {
+    if (j == i)
+      continue;
+    
+    int w_i = (i < j) ? i : j;
+    int w_j = (j > i) ? j : i;
+    
+    activation += NUM2DBL(rb_ary_entry(rb_ary_entry(weights, w_i), w_j)) * NUM2DBL(rb_ary_entry(neurons, j));
+  }
+  
+  return hopfield_transfer_activation(activation);
+}
+
+static VALUE hopfield_calculate_state_errors(VALUE self, VALUE state, VALUE patterns) {
+  Check_Type(state, T_ARRAY);
+  Check_Type(patterns, T_ARRAY);
+  
+  // Compare state to patterns and calculate errors for each pattern
+  int patterns_count = (int) RARRAY_LEN(patterns);
+  int pattern_length = (int) RARRAY_LEN(state);
+  
+  VALUE errors = rb_ary_new2(patterns_count);
+  
+  for(int p = 0; p < patterns_count; p++) {
+    int sum = 0;
+    
+    for(int c = 0; c < pattern_length; c++) {
+      int state_value = FIX2INT(rb_ary_entry(state, c));
+      int pattern_value = FIX2INT(rb_ary_entry(rb_ary_entry(patterns, p), c));
+      if (pattern_value != state_value)
+        sum++;
+    }
+    
+    rb_ary_push(errors, INT2FIX(sum));
+  }
+  
+  return errors;
+}
+
 /* ruby calls this to load the extension */
 void Init_hopfield(void) {
   
   m_hopfield = rb_define_module("Hopfield");
   
   rb_define_module_function(m_hopfield, "calculate_weights_hebbian", hopfield_calculate_weights_hebbian, 2);
+  rb_define_module_function(m_hopfield, "calculate_neuron_state", hopfield_calculate_neuron_state, 3);
+  
+  rb_define_module_function(m_hopfield, "calculate_state_errors", hopfield_calculate_state_errors, 2);
 }

data/lib/hopfield.rb

@@ -1,12 +1,12 @@
 require 'hopfield/hopfield'
 
-require_relative 'hopfield/neuron'
 require_relative 'hopfield/training'
 require_relative 'hopfield/network'
 
 module Hopfield
-  # Hopfield consists of three parts:
-  # => Neuron   (hopfield/neuron.rb)
+  # Hopfield consists of two parts:
   # => Training (hopfield/training.rb)
   # => Network  (hopfield/network.rb)
+  
+  USE_C_EXTENSION = true
 end

data/lib/hopfield/network.rb

@@ -1,6 +1,6 @@
 module Hopfield
   class Network
-    attr_accessor :neurons, :patterns, :weights, :state, :pattern_dimensions, :last_error, :runs
+    attr_accessor :neurons, :patterns, :weights, :state, :pattern_dimensions, :last_error, :runs, :random_pool, :random_pool_index
     
     def initialize(training, perturbed_pattern)
       unless training.class.to_s == 'Hopfield::Training'
@@ -20,9 +20,14 @@ module Hopfield
       self.pattern_dimensions = training.pattern_dimensions
       
       self.neurons.count.times do |i|
-        self.neurons[i].state = perturbed_pattern[i]
+        self.neurons[i] = perturbed_pattern[i]
       end
       
+      # Create a semi random pool to improve performance
+      # This prevents propagation of the same neuron over and over again
+      self.random_pool =        (0...self.neurons.count).to_a.shuffle
+      self.random_pool_index =  rand(self.neurons.count)
+      
       self.last_error = [1]
       self.runs =       0
     end
@@ -42,24 +47,39 @@ module Hopfield
     
     def propagate
       # Select random neuron
-      i = rand(self.neurons.count)
+      if self.random_pool_index == self.random_pool.size - 1
+        self.random_pool_index = 0
+        self.random_pool.shuffle!
+      end
       
-      activation = 0.0
+      i = self.random_pool[self.random_pool_index]
+      self.random_pool_index += 1
       
-      self.neurons.each_with_index do |other, j|
-        next if i == j
-        activation += get_weight(i, j)*other.state
+      if USE_C_EXTENSION
+        output = Hopfield::calculate_neuron_state(i, self.neurons, self.weights)
+      else
+        # Ruby equivalent of calculate_neuron_state C function
+        activation = 0.0
+        self.neurons.each_with_index do |other, j|
+          next if i == j
+          activation += get_weight(i, j)*other
+        end
+        output = transfer(activation)
       end
       
-      output = transfer(activation)
-      change = output != self.neurons[i].state
-      self.neurons[i].state = output
+      change = output != self.neurons[i]
+      self.neurons[i] = output
       
       # Compile state of outputs
-      state = Array.new(self.neurons.count){ |i| self.neurons[i].state }
+      state = self.neurons
 
       # Calculate the current error
-      self.last_error = calculate_error(state)
+      if USE_C_EXTENSION
+        self.last_error = Hopfield::calculate_state_errors(state, self.patterns)
+      else
+        # Ruby equivalent of calcuting the current error
+        self.last_error = calculate_error(state)
+      end
 
       # Convert state to binary and back to a multi dimensional array
       state = to_binary(state)
@@ -69,9 +89,9 @@ module Hopfield
       self.runs += 1
       
       return {
-        :did_change => change, 
-        :state => self.state,
-        :error => self.last_error
+        did_change: change, 
+        state: self.state,
+        error: self.last_error
       } 
     end
     

data/lib/hopfield/training.rb

@@ -5,8 +5,6 @@ module Hopfield
   HEBBIAN_RULE = 1
   STORKEY_RULE = 2
   
-  USE_C_EXTENSION = true
-  
   class Training
     attr_accessor :patterns, :neurons, :weights, :pattern_dimensions,  :rule
     
@@ -31,7 +29,7 @@ module Hopfield
       self.patterns = self.patterns.map { |pattern| pattern.map { |value| (value == 0 ? -1 : value) }}
       
       # Create neurons
-      self.neurons = Array.new(self.patterns.first.length) { Neuron.new }
+      self.neurons = Array.new(self.patterns.first.length) { 0.0 }
       
       self.weights = Array.new
       

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hopfield
 version: !ruby/object:Gem::Version
-  version: '1.2'
+  version: '1.3'
 platform: ruby
 authors:
 - Bart Olsthoorn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-03 00:00:00.000000000 Z
+date: 2013-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -24,20 +24,6 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: chunky_png
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 description: Hopfield networks can be used for smart pattern recollections. It's recalling
   patterns by modelling associative memory of a neural network
 email:
@@ -48,7 +34,6 @@ extensions:
 extra_rdoc_files: []
 files:
 - lib/hopfield/network.rb
-- lib/hopfield/neuron.rb
 - lib/hopfield/training.rb
 - lib/hopfield.rb
 - ext/hopfield/hopfield.c

data/lib/hopfield/neuron.rb

@@ -1,5 +0,0 @@
-module Hopfield
-  class Neuron
-    attr_accessor :state
-  end
-end