hopfield 1.0

data/LICENSE

@@ -0,0 +1,22 @@
+ Copyright (c) 2012  Bart Olsthoorn, website: bartolsthoorn.nl
+
+ 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.md

@@ -0,0 +1,30 @@
+# Hopfield Network in Ruby
+
+## 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. 
+
+The patterns can be passed using multi dimensional array of either 0 and 1 or -1 and 1. An artifical neural network will learn the patterns. Now let's move on to an example.
+
+## How do I use it?
+```ruby
+training = Hopfield::Training.new([pattern1, pattern2])
+network = Hopfield::Network.new(training, perturbed_pattern)
+network.pattern # the matched pattern
+network.runs # how many propagations it took
+```
+
+## Example with images
+See examples/image.rb for a memory association of Charlie Sheen, with a cat hiding him.
+```
+$ cd examples
+$ ruby image.rb
+Image 1 is now in an array of [20x20]
+Image 2 is now in an array of [20x20]
+Hopfield neurons are trained!
+Neurons propagated: 1776
+Errors: [0]
+```
+The script also creates black and white pattern images for you.
+
+## Credits
+I was introduced to Hopfield networks through the book [Clever Algorithms](www.cleveralgorithms.com), and I've borrowed bits of the implementation shown in the book. Also used the `.associated?` syntax found here: [Brain](https://github.com/brainopia/brain).

data/lib/hopfield.rb

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

data/lib/hopfield/network.rb

@@ -0,0 +1,92 @@
+module Hopfield
+  class Network
+    attr_accessor :neurons, :patterns, :state, :pattern_width, :vector, :last_error, :runs
+    
+    def initialize(training, perturbed_pattern)
+      unless training.class.to_s == 'Hopfield::Training'
+        raise TypeError, 'Training has to be an instance of Hopfield::Training'
+      end
+      
+      unless training.patterns.first.size == perturbed_pattern.size
+        raise SyntaxError, 'Given pattern does not match size of the training patterns'
+      end
+      
+      # Turn 0 into -1
+      perturbed_pattern.map {|value| (value == 0 ? -1 : value) }
+      
+      self.neurons =  training.neurons
+      self.patterns = training.patterns
+      self.pattern_width = training.pattern_width
+      self.vector =   perturbed_pattern.flatten
+      self.neurons.each_with_index { |neuron,i| neuron.output = self.vector[i] }
+      
+      self.last_error = [1]
+      self.runs =       0
+    end
+    
+    def associated?
+      return self.last_error.include? 0
+    end
+    
+    def pattern
+      return self.state
+    end
+    
+    def propagate
+      # Select random neuron
+      i = rand(self.neurons.size)
+      activation = 0
+      self.neurons.each_with_index do |other, j|
+        activation += other.weights[i]*other.output if i!=j
+      end
+      output = transfer(activation)
+      change = output != self.neurons[i].output
+      self.neurons[i].output = output
+      
+      # Compile state of outputs
+      state = Array.new(self.neurons.size){|i| self.neurons[i].output}
+      
+      # Calculate the current error
+      self.last_error = calculate_error(state)
+      
+      # Convert state to binary and back to a multi dimensional array
+      state = to_binary(state)
+      state = state.each_slice(self.pattern_width).to_a
+      self.state = state
+      
+      self.runs += 1
+      
+      return {
+        :did_change => change, 
+        :state => self.state,
+        :error => self.last_error
+      } 
+    end
+    
+    def calculate_error(current_pattern)
+      errors = Array.new(0)
+      
+      self.patterns.each do |pattern|
+        sum = 0
+      
+        expected = pattern.flatten
+        actual = current_pattern
+      
+        expected.each_with_index do |v, i|
+          sum += 1 if expected[i]!=actual[i]
+        end
+        errors << sum
+      end
+      return errors
+    end
+    
+    def transfer(activation)
+      (activation >= 0 ? 1 : -1)
+    end
+    
+    def to_binary(vector)
+      return Array.new(vector.size){|i| ((vector[i]==-1) ? 0 : 1)}
+    end
+    
+  end
+end

data/lib/hopfield/neuron.rb

@@ -0,0 +1,18 @@
+module Hopfield
+  class Neuron
+    attr_accessor :weights, :output
+    
+    def initialize(pattern_size)
+      minmax = Array.new(pattern_size) { [-0.5, 0.5] }
+      
+      self.weights =  random_vector(minmax)
+    end
+    
+    def random_vector(minmax)
+      return Array.new(minmax.size) do |i|
+        minmax[i][0] + ((minmax[i][1] - minmax[i][0]) * rand())
+      end
+    end
+    
+  end
+end

data/lib/hopfield/training.rb

@@ -0,0 +1,47 @@
+module Hopfield
+  class Training
+    attr_accessor :patterns, :neurons, :pattern_width
+    
+    def initialize(patterns)
+      # Check if patterns are the same size
+      unless patterns.map(&:size).uniq.count == 1
+        raise SyntaxError, 'Inconsistent pattern size'
+      end
+      
+      # Turn 0 into -1
+      patterns.map { |pattern| pattern.map {|value| (value == 0 ? -1 : value) }}
+      
+      # Set the patterns for this training
+      self.patterns = patterns
+      
+      # Calculate the amount of required neurons
+      # This number is based on the number of inputs of a pattern
+      connections =  patterns.first.map(&:size).inject{|sum,x| sum + x }
+      self.pattern_width = patterns.first.first.size
+      
+      # Create neurons
+      self.neurons = Array.new(connections) { Neuron.new connections }
+      
+      # Train the neurons
+      train(connections)
+    end
+    
+    def train(connections)
+      self.neurons.each_with_index do |neuron, i|  
+        for j in ((i+1)...connections) do
+          wij = 0.0
+          self.patterns.each do |pattern|
+            vector = pattern.flatten
+            #puts "Pattern: " + pattern.size.to_s
+            #puts "Pattern Y: " + pattern.first.size.to_s
+            #puts "Vector: " + vector.size.to_s
+            wij += vector[i]*vector[j]
+          end
+          self.neurons[i].weights[j] = wij
+          self.neurons[j].weights[i] = wij
+        end
+      end
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: hopfield
+version: !ruby/object:Gem::Version
+  version: '1.0'
+  prerelease: 
+platform: ruby
+authors:
+- Bart Olsthoorn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: chunky_png
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    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:
+- bartolsthoorn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hopfield/network.rb
+- lib/hopfield/neuron.rb
+- lib/hopfield/training.rb
+- lib/hopfield.rb
+- LICENSE
+- README.md
+homepage: http://github.com/bartolsthoorn/ruby-hopfield
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby implementation of a Hopfield Network
+test_files: []
+has_rdoc: