ruby-processing 2.4.3 → 2.4.4

data/samples/external_library/java_processing/custom/README.md

@@ -0,0 +1,15 @@
+Building the custom nn Library
+==============================
+This is an example of a java library that you can build yourself with the included Rakefile.
+Ideally you will both have ant and jruby installed (you should also have a jdk-7+ installed).
+
+If you have done all of that compiling and building jar is dead easy just issue the following command in a console.
+
+`jruby -S rake`
+
+you may also need to set JAVA_HOME to point to your jdk eg
+
+`export JAVA_HOME=/opt/jdk1.7.0_51` for linux users 
+
+
+This example was taken from [The Nature of Code](https://github.com/shiffman/The-Nature-of-Code) by Dan Shiffman, except the example has been rubified (and even the java code was doctored to be more up to date, and to prefer double to float).

data/samples/external_library/java_processing/custom/Rakefile

@@ -0,0 +1,28 @@
+require 'ant'
+
+PROJECT_NAME ='nn'
+MAIN_SRC_DIR = 'src'
+BUILD_DIR = 'build'
+DIST_DIR = 'library/nn'
+
+task :default => [:clean, :make_jars]
+
+task :clean do
+  ant.delete :dir => BUILD_DIR
+  puts
+end
+
+task :make_jars => :clean do
+  make_jar MAIN_SRC_DIR, "#{PROJECT_NAME}.jar"
+end
+
+def make_jar(source_folder, jar_file_name) 
+    ant.mkdir :dir => BUILD_DIR
+    ant.mkdir :dir => DIST_DIR
+    ant.javac :srcdir => source_folder, :destdir => BUILD_DIR, 
+              :source => "1.7", :target => "1.7", :debug => "yes", :includeantruntime => "no"
+    ant.jar :jarfile => "#{DIST_DIR}/#{jar_file_name}", :basedir => BUILD_DIR
+    ant.delete :dir => BUILD_DIR
+    puts
+end
+

data/samples/external_library/java_processing/custom/landscape.rb

@@ -0,0 +1,58 @@
+# The Nature of Code
+# Daniel Shiffman
+# http:#natureofcode.com
+
+# "Landscape" example
+
+class Landscape
+  include Processing::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))
+  end
+  
+  
+  # Calculate height values (based off a neural network)
+  def calculate(nn)
+    val = ->(curr, nn, x, y){curr * 0.95 + 0.05 *  (nn.feed_forward([x, y]) * 280.0 - 140.0)} 
+    @z = (0 ... cols).map{|i|
+      (0 ... rows).map{|j| val.call(z[i][j], nn, i * 1.0/ cols, j * 1.0/cols)}      
+    }   
+  end
+  
+  # Render landscape as grid of quads
+  def render
+    # Every cell is an individual quad
+    # (could use quad_strip here, but produces funny results, investigate this)
+    (0 ... z.size - 1).each do |x|      
+      (0 ... z[0].size - 1).each do |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
+end
+

data/samples/external_library/java_processing/custom/src/nn/Connection.java

@@ -0,0 +1,47 @@
+// Daniel Shiffman
+// The Nature of Code, Fall 2006
+// Neural Network
+
+// Class to describe a connection between two neurons
+
+package nn;
+
+public class Connection {
+
+    private final Neuron from;     // Connection goes from. . .
+    private final Neuron to;       // To. . .
+    private double weight;   // Weight of the connection. . .
+
+    // Constructor  builds a connection with a random weight
+    public Connection(Neuron a_, Neuron b_) {
+        from = a_;
+        to = b_;
+        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_;
+        to = b_;
+        weight = w;
+    }
+
+    public Neuron getFrom() {
+        return from;
+    }
+    
+    public Neuron getTo() {
+        return to;
+    }  
+    
+    public double getWeight() {
+        return weight;
+    }
+
+    // Changing the weight of the connection
+    public void adjustWeight(double deltaWeight) {
+        weight += deltaWeight;
+    }
+
+
+}

data/samples/external_library/java_processing/custom/src/nn/HiddenNeuron.java

@@ -0,0 +1,20 @@
+//Daniel Shiffman
+//The Nature of Code, Fall 2006
+//Neural Network
+
+// Hidden Neuron Class
+// So far not necessary to differentiate these
+
+package nn;
+
+public class HiddenNeuron extends Neuron {
+    
+    public HiddenNeuron() {
+        super();
+    }
+    
+    public HiddenNeuron(int i) {
+        super(i);
+    }
+    
+}

data/samples/external_library/java_processing/custom/src/nn/InputNeuron.java

@@ -0,0 +1,23 @@
+//Daniel Shiffman
+//The Nature of Code, Fall 2006
+//Neural Network
+
+// Input Neuron Class
+// Has additional functionality to receive beginning input
+
+package nn;
+
+public class InputNeuron extends Neuron {
+    public InputNeuron() {
+        super();
+    }
+    
+    public InputNeuron(int i) {
+        super(i);
+    }
+
+    public void input(double d) {
+        output = d;
+    }
+
+}

data/samples/external_library/java_processing/custom/src/nn/Network.java

@@ -0,0 +1,136 @@
+// Daniel Shiffman
+// The Nature of Code, Fall 2006
+// Neural Network
+
+// Class to describe the entire network
+// Arrays for input_array neurons, hidden_array 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_array layer
+
+package nn;
+
+import java.util.ArrayList;
+
+public class Network {
+
+    // Layers
+    InputNeuron[] input_array;
+    HiddenNeuron[] hidden_array;
+    OutputNeuron output;
+    
+    public static final double LEARNING_CONSTANT = 0.5;
+
+    // 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_array layer
+    // Only One hidden_array layer!!!  (fix this dood)
+
+    public Network(int inputs, int hidden_arraytotal) {
+
+        input_array = new InputNeuron[inputs+1];  // Got to add a bias input_array
+        hidden_array = new HiddenNeuron[hidden_arraytotal+1];
+
+        // Make input_array neurons
+        for (int i = 0; i < input_array.length-1; i++) {
+            input_array[i] = new InputNeuron();
+        }
+        
+        // Make hidden_array neurons
+        for (int i = 0; i < hidden_array.length-1; i++) {
+            hidden_array[i] = new HiddenNeuron();
+        }
+
+        // Make bias neurons
+        input_array[input_array.length-1] = new InputNeuron(1);
+        hidden_array[hidden_array.length-1] = new HiddenNeuron(1);
+
+        // Make output neuron
+        output = new OutputNeuron();
+        for (InputNeuron input : input_array) {
+            for (int j = 0; j < hidden_array.length-1; j++) {
+                // Create the connection object and put it in both neurons
+                Connection c = new Connection(input, hidden_array[j]);
+                input.addConnection(c);
+                hidden_array[j].addConnection(c);
+            }
+        }
+        for (HiddenNeuron hidden : hidden_array) {
+            Connection c = new Connection(hidden, output);
+            hidden.addConnection(c);
+            output.addConnection(c);
+        }
+
+    }
+
+
+    public double feedForward(double[] inputVals) {
+        
+        // Feed the input_array with an array of inputs
+        for (int i = 0; i < inputVals.length; i++) {
+            input_array[i].input(inputVals[i]);  
+        }
+        
+        // Have the hidden_array layer calculate its output
+        for (int i = 0; i < hidden_array.length-1; i++) {
+            hidden_array[i].calcOutput();
+        }
+
+        // Calculate the output of the output neuron
+        output.calcOutput();
+        
+        // Return output
+        return output.getOutput();
+    }
+
+    public double train(double[] inputs, double answer) {
+        double result = feedForward(inputs);
+        
+        
+        // This is where the error correction all starts
+        // Derivative of sigmoid output function * diff between known and guess
+        double deltaOutput = result * (1 - result) * (answer - result);
+
+        
+        // BACKPROPOGATION
+        // This is easier b/c we just have one output
+        // Apply Delta to connections between hidden_array and output
+        ArrayList<Connection> connections = output.getConnections();
+        for (int i = 0; i < connections.size(); i++) {
+            Connection c = connections.get(i);
+            Neuron neuron = c.getFrom();
+            double temp_output = neuron.getOutput();
+            double deltaWeight = temp_output * deltaOutput;
+            c.adjustWeight(LEARNING_CONSTANT * deltaWeight);
+        }
+        for (HiddenNeuron hidden : hidden_array) {
+            connections = hidden.getConnections();
+            double sum  = 0;
+            // Sum output delta * hidden_array layer connections (just one output)
+            for (int j = 0; j < connections.size(); j++) {
+                Connection c = connections.get(j);
+                // Is this a connection from hidden_array layer to next layer (output)?
+                if (c.getFrom() == hidden) {
+                    sum += c.getWeight() * deltaOutput;
+                }
+            }    
+            // Then adjust the weights coming in based:
+            // Above sum * derivative of sigmoid output function for hidden_array neurons
+            for (int j = 0; j < connections.size(); j++) {
+                Connection c = connections.get(j);
+                // Is this a connection from previous layer (input_array) to hidden_array layer?
+                if (c.getTo() == hidden) {
+                    double temp_output = hidden.getOutput();
+                    double deltaHidden = temp_output * (1 - temp_output);  // Derivative of sigmoid(x)
+                    deltaHidden *= sum;   // Would sum for all outputs if more than one output
+                    Neuron neuron = c.getFrom();
+                    double deltaWeight = neuron.getOutput() * deltaHidden;
+                    c.adjustWeight(LEARNING_CONSTANT * deltaWeight);
+                }
+            } 
+        }
+        return result;
+    }
+}

data/samples/external_library/java_processing/custom/src/nn/Neuron.java

@@ -0,0 +1,79 @@
+//Daniel Shiffman
+//The Nature of Code, Fall 2006
+//Neural Network
+
+//Generic Neuron Class
+//Can be a bias neuron (true or false)
+
+package nn;
+
+import java.util.ArrayList;
+
+public class Neuron {
+
+    protected double output;
+    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<>();
+        bias = false;
+    }
+
+    // Constructor for a bias neuron
+    public Neuron(int i) {
+        output = i;
+        connections = new ArrayList<>();
+        bias = true;
+    }
+
+    // Function to calculate output of this neuron
+    // Output is sum of all inputs * weight of connections
+    public void calcOutput() {
+        if (bias == false) {
+            double sum = 0;
+            double bias_value = 0;
+            //System.out.println("Looking through " + connections.size() + " connections");
+            for (int i = 0; i < connections.size(); i++) {
+                Connection c = connections.get(i);
+                Neuron from = c.getFrom();
+                Neuron to = c.getTo();
+                // Is this connection moving forward to us
+                // Ignore connections that we send our output to
+                if (to == this) {
+                    // This isn't really necessary
+                    // But I am treating the bias individually in case I need to at some point
+                    if (from.bias) {
+                        bias_value = from.getOutput()*c.getWeight();
+                    } else {
+                        sum += from.getOutput()*c.getWeight();
+                    }
+                }
+            }
+            // Output is result of sigmoid function
+            output = f(bias_value + sum);
+        }
+    }
+
+    void addConnection(Connection c) {
+        connections.add(c);
+    }
+
+    double getOutput() {
+        return output;
+    }
+
+    // Sigmoid function
+    public static double f(double x) {
+        return 1.0 / (1.0 +  Math.exp(-x));
+    }
+
+    public ArrayList<Connection> getConnections() {
+        return connections;
+    }
+
+
+}

data/samples/external_library/java_processing/custom/src/nn/OutputNeuron.java

@@ -0,0 +1,7 @@
+package nn;
+
+public class OutputNeuron extends Neuron {
+    public OutputNeuron() {
+        super();
+    }
+}

data/samples/external_library/java_processing/custom/xor.rb

@@ -0,0 +1,88 @@
+# The Nature of Code
+# Daniel Shiffman
+# http://natureofcode.com
+
+# XOR Multi-Layered Neural Network Example
+# Neural network java code is all in the "src" folder
+load_library :nn
+
+require_relative './landscape'
+include_package 'nn'
+
+ITERATIONS_PER_FRAME = 5
+
+attr_reader :inputs, :nn, :count, :land, :theta, :f, :result, :known
+
+
+def setup
+  
+  size(400, 400, P3D)
+  @theta = 0.0
+  # Create a landscape object
+  @land = Landscape.new(20, 300, 300)
+  @f = create_font("Courier", 12, true)
+  
+  @nn = Network.new(2, 4)
+  @count = 0
+  # Create a list of 4 training inputs
+  @inputs = []
+  inputs << [1.0, 0]
+  inputs << [0, 1.0] 
+  inputs << [1.0, 1.0] 
+  inputs << [0, 0.0]
+end
+
+def draw  
+  lights  
+  ITERATIONS_PER_FRAME.times do |i|
+    inp = inputs.sample
+    # Compute XOR    
+    @known = ((inp[0] > 0.0 && inp[1] > 0.0) || (inp[0] < 1.0 && inp[1] < 1.0))? 0 : 1.0 
+    
+    # Train that sucker!
+    @result = nn.train(inp, known)
+    @count += 1
+  end 
+  
+  # Ok, visualize the solution space
+  background(175)
+  push_matrix
+  translate(width / 2, height / 2 + 20, -160)
+  rotate_x(Math::PI / 3)
+  rotate_z(theta)
+  
+  # Put a little BOX on screen
+  push_matrix
+ 
+  stroke(50)
+  no_fill
+  translate(-10, -10, 0)
+  box(280)
+  land.calculate(nn)
+  land.render
+  # Draw the landscape
+  pop_matrix
+   
+  @theta += 0.0025
+  pop_matrix
+  
+  # Display overal neural net stats
+  network_status  
+end  
+
+def network_status
+  mse = 0.0  
+  text_font(f)
+  fill(0)
+  text("Your friendly neighborhood neural network solving XOR.", 10, 20)
+  text("Total iterations: #{count}", 10, 40)
+  mse += (result - known) * (result - known)    
+  rmse = Math::sqrt(mse / 4.0)
+  out = "Root mean squared error: #{format("%.5f", rmse)}"
+  hint DISABLE_DEPTH_SORT
+  text(out, 10, 60) 
+  hint ENABLE_DEPTH_SORT
+end
+
+
+