pure ruby alternative

Author: monkstone

nature-of-code/xor/src/nn/Connection.java

@@ -16,9 +16,9 @@ public class Connection {
     public Connection(Neuron a_, Neuron b_) {
         from = a_;
         to = b_;
-        weight = (double) Math.random()*2-1;
+        weight = Math.random()*2-1;
     }
-    
+
     // In case I want to set the weights manually, using this for testing
     public Connection(Neuron a_, Neuron b_, double w) {
         from = a_;
@@ -29,11 +29,11 @@ public Connection(Neuron a_, Neuron b_, double w) {
     public Neuron getFrom() {
         return from;
     }
-    
+
     public Neuron getTo() {
         return to;
-    }  
-    
+    }
+
     public double getWeight() {
         return weight;
     }
@@ -42,6 +42,4 @@ public double getWeight() {
     public void adjustWeight(double deltaWeight) {
         weight += deltaWeight;
     }
-
-
 }

nature-of-code/xor/src/nn/Neuron.java

@@ -12,14 +12,14 @@
 public class Neuron {
 
     protected double output;
-    protected ArrayList<Connection> connections; 
+    protected ArrayList<Connection> connections;
     protected boolean bias = false;
 
     // A regular Neuron
     public Neuron() {
         output = 0;
         // Using an arraylist to store list of connections to other neurons
-        connections = new ArrayList<>();  
+        connections = new ArrayList<>();
         bias = false;
     }
 
@@ -56,7 +56,7 @@ public void calcOutput() {
                 }
             }
             // Output is result of sigmoid function
-            output = f(lbias+sum);
+            output = f(lbias + sum);
         }
     }
 
@@ -76,6 +76,4 @@ public static double f(double x) {
     public ArrayList<Connection> getConnections() {
         return connections;
     }
-
-
 }

nature-of-code/xor_ruby/README.md

@@ -0,0 +1,6 @@
+Alternative xor (neural net) Library
+===================
+
+Here we translate the java library to pure ruby
+
+

nature-of-code/xor_ruby/landscape.rb

@@ -0,0 +1,55 @@
+# The Nature of Code
+# Daniel Shiffman
+# https://natureofcode.com
+
+# "Landscape" example
+class Landscape
+  include Propane::Proxy
+
+  attr_reader :scl, :w, :h, :rows, :cols, :z, :zoff
+
+  def initialize(scl, w, h)
+    @scl, @w, @h  = scl, w, h
+    @cols = w / scl
+    @rows = h / scl
+    @z = Array.new(cols, Array.new(rows, 0.0))
+    @zoff = 0
+  end
+
+  # Calculate height values (based off a neural network)
+  def calculate(nn)
+    val = lambda do |curr, net, x, y|
+      curr * 0.95 + 0.05 * (net.feed_forward([x, y]) * 280.0 - 140.0)
+    end
+    @z = (0...cols).map do |i|
+      (0...rows).map do |j|
+        val.call(z[i][j], nn, i * 1.0 / cols, j * 1.0 / cols)
+      end
+    end
+  end
+
+  # Render landscape as grid of quads
+  def render
+    # Every cell is an individual quad
+    # using the propane grid convenience function instead of a nested loop
+    grid(z.size - 1, z[0].size - 1) do |x, y|
+      # one quad at a time
+      # each quad's color is determined by the height value at each vertex
+      # (clean this part up)
+      no_stroke
+      push_matrix
+      begin_shape(QUADS)
+      translate(x * scl - w * 0.5, y * scl - h * 0.5, 0)
+      fill(z[x][y] + 127, 220)
+      vertex(0, 0, z[x][y])
+      fill(z[x + 1][y] + 127, 220)
+      vertex(scl, 0, z[x + 1][y])
+      fill(z[x + 1][y + 1] + 127, 220)
+      vertex(scl, scl, z[x + 1][y + 1])
+      fill(z[x][y + 1] + 127, 220)
+      vertex(0, scl, z[x][y + 1])
+      end_shape
+      pop_matrix
+    end
+  end
+end

nature-of-code/xor_ruby/library/xor/lib/connection.rb

@@ -0,0 +1,13 @@
+class Connection
+  attr_reader :from, :to, :weight
+
+  def initialize(from, to, weight = rand(-1..1.0))
+    @from = from
+    @to = to
+    @weight = weight
+  end
+
+  def adjust_weight(delta)
+    @weight += delta
+  end
+end

nature-of-code/xor_ruby/library/xor/lib/input_neuron.rb

@@ -0,0 +1,5 @@
+class InputNeuron < Neuron
+  def input(data)
+    @output = data
+  end
+end

nature-of-code/xor_ruby/library/xor/lib/network.rb

@@ -0,0 +1,100 @@
+# Daniel Shiffman
+# The Nature of Code, Fall 2006
+# Neural Network
+# Class to describe the entire network
+# Arrays for input neurons, hidden neurons, and output neuron
+# Need to update this so that it would work with an array out outputs
+# Rather silly that I didn't do this initially
+# Also need to build in a "Layer" class so that there can easily
+# be more than one hidden layer
+class Network
+  LEARNING_CONSTANT = 0.5
+  attr_reader :input, :hidden, :output
+  # Only One output now to start!!! (i can do better, really. . .)
+  # Constructor makes the entire network based on number of inputs & number of
+  # neurons in hidden layer
+  # Only One hidden layer!!!  (fix this dood)
+  def initialize(inputs, hidden_total)
+    @input = (0..inputs).map { InputNeuron.new } # Got to add a bias input
+    @hidden = (0..hidden_total).map { Neuron.new } # same as regular Neuron
+    # Make bias neurons
+    input[inputs] = Neuron.new(1)
+    hidden[hidden_total] = Neuron.new(1)
+    # Make output neuron
+    @output = Neuron.new # same as regular Neuron
+    # Connect input layer to hidden layer
+    input.each do |input1|
+      (0...hidden.length).each do |j|
+        # Create the object and put it in both neurons
+        c = Connection.new input1, hidden[j]
+        input1.add_connection(c)
+        hidden[j].add_connection(c)
+      end
+    end
+    # Connect the hidden layer to the output neuron
+    hidden.each do |hidden1|
+      c = Connection.new(hidden1, output)
+      hidden1.add_connection(c)
+      output.add_connection(c)
+    end
+  end
+
+  def feed_forward(input_vals)
+    # Feed the input with an array of inputs
+    input_vals.each_with_index do |val, i|
+      input[i].input(val)
+    end
+
+    # Have the hidden layer calculate its output
+    (0...hidden.length).each do |i|
+      hidden[i].calc_output
+    end
+
+    # Calculate the output of the output neuron
+    output.calc_output
+
+    # Return output
+    output.output
+  end
+
+  def train(inputs, answer)
+    result = feed_forward(inputs)
+    # This is where the error correction all starts
+    # Derivative of sigmoid output function * diff between known and guess
+    delta_output = result * (1 - result) * (answer - result)
+    # BACKPROPOGATION
+    # This is easier b/c we just have one output
+    # Apply Delta to connections between hidden and output
+    connections = output.connections
+    connections.each do |c|
+      neuron = c.from
+      loutput = neuron.output
+      delta_weight = loutput * delta_output
+      c.adjust_weight(LEARNING_CONSTANT * delta_weight)
+    end
+
+    # ADJUST HIDDEN WEIGHTS
+    hidden.each do |hidden1|
+      connections = hidden1.connections
+      sum = 0
+      # Sum output delta * hidden layer connections (just one output)
+      connections.each do |c|
+        # Is this a from hidden layer to next layer (output)?
+        sum += c.weight * delta_output if c.from == hidden1
+      end
+      # Then adjust the weights coming in based:
+      # Above sum * derivative of sigmoid output function for hidden neurons
+      connections.each do |c|
+        # Is this a from previous layer (input) to hidden layer?
+        next unless c.to == hidden1
+        loutput = hidden1.output
+        delta_hidden = loutput * (1 - loutput) # Derivative of sigmoid(x)
+        delta_hidden *= sum # Would sum for all outputs if more than one output
+        neuron = c.from
+        delta_weight = neuron.output * delta_hidden
+        c.adjust_weight(LEARNING_CONSTANT * delta_weight)
+      end
+    end
+    result
+  end
+end

nature-of-code/xor_ruby/library/xor/lib/neuron.rb

@@ -0,0 +1,39 @@
+class Neuron
+  attr_reader :output, :connections, :bias
+
+  def initialize(output = 0)
+    @connections = []
+    @output = output
+    @bias = !output.zero?
+  end
+
+  def add_connection(c)
+    connections << c
+  end
+
+  def calc_output
+    return if bias #  do nothing
+    sigmoid = ->(x) { 1.0 / (1.0 + Math.exp(-x)) }
+    sum = 0
+    lbias = 0
+    # fstring = 'Looking through %d connections'
+    # puts(format(fstring, connections.size))
+    connections.each do |c|
+      from = c.from
+      to = c.to
+      #  Is this connection moving forward to us
+      #  Ignore connections that we send our output to
+      if to == self
+        #  This isn't really necessary
+        #  Ttreating the bias individually in case needed to at some point
+        if from.bias
+          lbias = from.output * c.weight
+        else
+          sum += from.output * c.weight
+        end
+      end
+    end
+    #  Output is result of sigmoid function
+    @output = sigmoid.call(lbias + sum)
+  end
+end

nature-of-code/xor_ruby/library/xor/test/connection_test.rb

@@ -0,0 +1,26 @@
+require_relative 'test_helper'
+require 'java'
+require_relative '../xor'
+
+class ConnectionTest < Minitest::Test
+
+ def test_new_from_to
+    from = Neuron.new(1)
+    to = Neuron.new(2)
+    connection = Connection.new from, to
+  end
+
+  def test_new_from_to_weight
+     from = Neuron.new(1)
+     to = Neuron.new(2)
+     connection = Connection.new from, to, rand(-1..1.0)
+   end
+
+   def test_adjust_weight
+      from = Neuron.new(1)
+      to = Neuron.new(2)
+      connection = Connection.new from, to, 0.5
+      connection.adjust_weight(0.2)
+      assert_in_epsilon(0.7, connection.weight)
+    end
+end

nature-of-code/xor_ruby/library/xor/test/input_neuron_test.rb

@@ -0,0 +1,26 @@
+require_relative 'test_helper'
+require 'java'
+require_relative '../xor'
+
+
+class NeuronTest < Minitest::Test
+
+  def test_new_no_param
+    neuron = InputNeuron.new
+    assert !neuron.bias
+    assert neuron.output.zero?
+  end
+
+  def test_newparam
+    input = 1
+    neuron = InputNeuron.new input
+    assert neuron.bias
+    assert_equal neuron.output, input
+  end
+
+  def test_input
+    neuron = InputNeuron.new
+    neuron.input 2
+    assert_equal 2, neuron.output
+  end
+end