add neural net animation example

Author: monkstone

nature-of-code/animation/Exercise_10_05_LayeredNetworkAnimation.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env jruby
+require 'propane'
+
+class LayeredNetwork < Propane::App
+  # The Nature of Code
+  # Daniel Shiffman
+  # http://natureofcode.com
+
+  # An animated drawing of a Neural Network
+  load_libraries :neural_network
+
+  attr_reader :network, :output
+
+  def setup
+    sketch_title 'Exercise 10 05 Layered Network Animation'
+    # Create the Network object
+    @network = Network.new(width / 2, height / 2)
+    layers = 3
+    inputs = 2
+    @output = Neuron.new 250, 0
+    (0...layers).each do |i|
+      inputs.times do |j|
+        x = map1d(i, (0..layers), (-250..300))
+        y = map1d(j, (0..inputs - 1), (-75..75))
+        n = Neuron.new(x, y)
+        if i > 0
+          (0...inputs).each do |k|
+            prev = network.neurons[network.neurons.size - inputs + k - j]
+            network.connect(prev, n, rand)
+          end
+        end
+        network.connect(n, output, rand) if (i == layers - 1)
+        network.add_neuron(n)
+      end
+    end
+    network.add_neuron(output)
+  end
+
+  def draw
+    background 255
+    # Update and display the Network
+    network.update
+    network.display
+    # Every 30 frames feed in an input
+    network.feedforward(rand, rand) if (frame_count % 30 == 0)
+  end
+
+  def settings
+    size 640, 360
+  end
+end
+
+LayeredNetwork.new

nature-of-code/animation/library/neural_network/lib/connection.rb

@@ -0,0 +1,53 @@
+# The Nature of Code
+# Daniel Shiffman
+# http://natureofcode.com
+
+# An animated drawing of a Neural Network
+
+class Connection
+  include Propane::Proxy
+  # Connection is from A to B
+  attr_reader :a, :b, :weight, :sending, :sender, :output
+
+  def initialize(from, to, w)
+    @weight, @a, @b = w, from, to
+    @sending = false
+    @sender = Vec2D.new
+    @output = 0
+  end
+
+  # The Connection is active
+  def feedforward(val)
+    @output = val * weight      # Compute output
+    @sender = a.origin          # Start animation at originating neuron
+    @sending = true             # Turn on sending
+  end
+
+  # Update traveling sender
+  def update
+    return unless sending       # favour a guard clause in ruby
+    # Use a simple interpolation
+    sender.lerp!(b.location, 0.1)
+    d = sender.dist(b.location)
+    # If we've reached the end
+    return unless d < 1
+    # Pass along the output!
+    b.feedforward(output)
+    @sending = false
+  end
+
+  # Draw line and traveling circle
+  def display
+    stroke(0)
+    stroke_weight(1 + weight * 4)
+    draw_line a.location, b.location
+    return unless sending
+    fill(0)
+    stroke_weight(1)
+    ellipse(sender.x, sender.y, 16, 16)
+  end
+
+  def draw_line(a, b)
+    line a.x, a.y, b.x, b.y
+  end
+end

nature-of-code/animation/library/neural_network/lib/network.rb

@@ -0,0 +1,52 @@
+# The Nature of Code
+# Daniel Shiffman
+# http:#natureofcode.com
+# An animated drawing of a Neural Network
+
+class Network
+  include Propane::Proxy
+  # The Network has a list of neurons
+  attr_reader :neurons, :connections, :location
+
+  def initialize(x, y)
+    @location = Vec2D.new(x, y)
+    @neurons = []
+    @connections = []
+  end
+
+  # We can add a Neuron
+  def add_neuron(n)
+    neurons << n
+  end
+
+  # We can connection two Neurons
+  def connect(a, b, weight = 0.5)
+    c = Connection.new a, b, weight
+    a.join c
+    # Also add the Connection here
+    connections << c
+  end
+
+  # Sending an input to the first Neuron
+  # We should do something better to track multiple inputs
+  def feedforward(input1, input2)
+    n1 = neurons[0]
+    n1.feedforward(input1)
+    n2 = neurons[1]
+    n2.feedforward(input2)
+  end
+
+  # Update the animation
+  def update
+    connections.each { |c| c.update }
+  end
+
+  # Draw everything
+  def display
+    push_matrix
+    translate(location.x, location.y)
+    neurons.each { |n| n.display }
+    connections.each { |c| c.display }
+    pop_matrix
+  end
+end

nature-of-code/animation/library/neural_network/lib/neuron.rb

@@ -0,0 +1,55 @@
+# Daniel Shiffman
+# The Nature of Code
+# http://natureofcode.com
+# An animated drawing of a Neural Network
+
+class Neuron
+  include Propane::Proxy
+  # Neuron has a location
+  attr_reader :location, :connections, :sum, :r
+
+  def initialize(x, y)
+    @sum = 0
+    @r = 32
+    @location = Vec2D.new(x, y)
+    @connections = []
+  end
+
+  # Add a Connection
+  def join(c)
+    connections << c
+  end
+
+  def origin
+    location.copy
+  end
+
+  # Receive an input
+  def feedforward(input)
+    # Accumulate it
+    @sum += input
+    # Activate it?
+    return sum unless sum > 1
+    fire
+    @sum = 0  # Reset the sum to 0 if it fires
+  end
+
+  # The Neuron fires
+  def fire
+    @r = 64   # It suddenly is bigger
+    # We send the output through all connections
+    connections.each { |c| c.feedforward(sum) }
+  end
+
+  # Draw it as a circle
+  def display
+    stroke(0)
+    stroke_weight(1)
+    # Brightness is mapped to sum
+    b = map1d(sum, (0 .. 1), (255 .. 0))
+    fill(b)
+    ellipse(location.x, location.y, r, r)
+    # Size shrinks down back to original dimensions
+    @r = lerp(r, 32, 0.1)
+  end
+end

nature-of-code/animation/library/neural_network/lib/static_network.rb

@@ -0,0 +1,38 @@
+# The Nature of Code
+# Daniel Shiffman
+# http://natureofcode.com
+
+class StaticNetwork
+  include Propane::Proxy
+  attr_reader :neurons, :location
+
+  def initialize(layers, inputs, _outputs)
+    @location = Vec2D.new($app.width / 2, $app.height / 2)
+    @neurons = []
+    output = Neuron.new(250, 0)
+    layers.times do |i|
+      inputs.times do |j|
+        x = map1d(i, (0 .. layers), (-200 .. 200))
+        y = map1d(j, (0 .. inputs-1), (-100 .. 100))
+        puts "#{j} #{y}"
+        n = Neuron.new(x, y)
+        if i > 0
+          inputs.times do |k|
+            prev = neurons[neurons.size - inputs + k - j]
+            prev.join(n)
+          end
+        end
+        n.join(output) if (i == layers - 1)
+        neurons << n
+      end
+    end
+    neurons << output
+  end
+
+  def display
+    push_matrix
+    translate(location.x, location.y)
+    neurons.each { |n| n.display }
+    pop_matrix
+  end
+end

nature-of-code/animation/library/neural_network/neural_network.rb

@@ -0,0 +1,6 @@
+# This file provides access to the below listed files via ruby-processing load_library
+
+require_relative 'lib/connection'
+require_relative 'lib/neuron'
+require_relative 'lib/network'
+require_relative 'lib/static_network'