the_noggin 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 53abd15e32f1bc58d542d5bb2480f4e6f1d75c89
-  data.tar.gz: cd335f6a5b853e04334690f16db4f57698cb916a
+  metadata.gz: 607a3501df480a778864de21cc7ad5cff59ea17a
+  data.tar.gz: 3cd6dd3d9fb66a40bb90cf8bf37d00af9e64a8cf
 SHA512:
-  metadata.gz: 8b740e1ba1f091ba957de78416fad3ab7758dc07aeb2af496300335a5ebaa490c00492000277e903ef47e7c3c34d5f3ba57d5f491c0e0cf6689690ed96bd98b0
-  data.tar.gz: 44a6217cedcf96933f0c902aecf95d5732439e2fee62d08205a7180ac80b6310070680bf3559574b46db24dc1a592ec1e9eca89449047ea372a0326e877f80e3
+  metadata.gz: 7e0caaabbe999c3f60fdd82edefebd455c066c4259760aa6c448c6ded85d15a13ae308d296bbe0ec0ffee30a14f64b5bc589f8f3a03aaa8454f7b694358eff80
+  data.tar.gz: 39e80d7c547bf95dd01cc6d51dcf72f6be7e2b0485766084c448440699af72a35225ff05b46e393deb07d33860e70a51686478be75c2556d84c7680ccf7f9ca4

data/README.md

@@ -1,19 +1,21 @@
 # Noggin
-Ruby Neural Network implementation using backpropagation and gradient descent for training
+A Neural Network written in Ruby with an objected oriented implementation. Training is done using http://en.wikipedia.org/wiki/Backpropagation and http://en.wikipedia.org/wiki/Gradient_descent.
+
+The simple API was inspired from https://github.com/harthur/brain
 
 
 ``` Ruby
 network = Noggin::Network.new
 
 network.train([
-  { input: [0, 0], output: 0 },
-  { input: [0, 1], output: 1 },
-  { input: [1, 0], output: 1 },
-  { input: [1, 1], output: 0 }
+  { input: [0, 0], expected: 0 },
+  { input: [0, 1], expected: 1 },
+  { input: [1, 0], expected: 1 },
+  { input: [1, 1], expected: 0 }
 ])
 
 network.run [0, 0]  # 0.0163
-network.run [0, 1]  # 0.9573
+network.run [0, 1]  # 0.9873
 network.run [1, 0]  # 0.9702
 network.run [1, 1]  # 0.0142
 
@@ -25,28 +27,10 @@ network.run [1, 1]  # 0.0142
 ## Options
 ``` Ruby
 Noggin::Network.new( 
-    max_training_laps: 100000, # How many propgation of errors to do when training
+    training_laps: 100000, # How many propgation of errors to do when training
     learning_rate: 0.1, # How fast the network learns
     momentum: 0.2, # How much of previous weight deltas should be applied to next delta  
     hidden_layer_size: 1 , # Number of hidden layers
     hidden_layer_node_size: 2, # Number of nodes each hidden layer has
-    log: true # print out network state for each input during last iteration.
 )
 ```
-
-## Print Network
-
-``` Ruby
-network.pretty_print
-```
-```
- ------                                           ------                                          --------------      
-|      | -EDGE--(w: 0.438443, d: 0.01759)        |      | -EDGE--(w: 0.515923, d: 0.09704)       | ed: 0.668486       
-|      | -EDGE--(w: 0.746539, d: 0.013825)        ------                                         | d: 0.148145        
- ------                                           ------                                         | e: 0.223437        
- ------                                          |      | -EDGE--(w: 0.485781, d: 0.11099)       | o: 0.668486        
-|      | -EDGE--(w: 0.199745, d: 0.01759)         ------                                          --------------      
-|      | -EDGE--(w: 0.345684, d: 0.013825)       
- ------                                          
-   
-```

data/lib/noggin.rb

@@ -1,6 +1,5 @@
-require 'noggin/node/base'
-require 'noggin/node/input'
-require 'noggin/node/output'
-require 'noggin/node/edge'
-require 'noggin/network'
-require 'noggin/pretty_printer'
+require 'noggin/neuron'
+require 'noggin/bias'
+require 'noggin/edge'
+require 'noggin/layer'
+require 'noggin/network'

data/lib/noggin/bias.rb

@@ -0,0 +1,23 @@
+module Noggin
+  class Bias
+
+    attr_accessor :dests, :forward_output
+
+    def initialize
+      @dests = []
+      @forward_output = 1
+    end
+
+    def forward_activate!
+      dests.each do |edge|
+        edge.forward_input = @forward_output
+        edge.forward_activate!
+      end
+    end
+
+    def learn!
+      dests.each(&:learn!)
+    end
+
+  end
+end

data/lib/noggin/edge.rb

@@ -0,0 +1,31 @@
+module Noggin
+  class Edge
+
+    attr_accessor :origin, :dest, :weight, :derivative, :forward_input, :forward_output, :backward_input, :backward_output
+
+    def initialize origin: origin, dest: dest, weight: rand(0.20...0.80), momentum: 1, learning_rate: 0.3
+      @origin = origin
+      @dest = dest
+      @weight = weight
+      @momentum = momentum
+      @previous_derivative = 0
+      @learning_rate = learning_rate
+    end
+
+    def forward_activate!
+      @forward_output = @forward_input * weight
+    end
+
+    def backward_activate!
+      @backward_output = dest.backward_output * weight
+      @derivative = dest.backward_output * origin.forward_output
+    end
+
+    def learn!
+      @weight -= @learning_rate * @derivative + (@previous_derivative * @momentum)
+      @previous_derivative = @derivative
+    end
+
+  end
+end
+

data/lib/noggin/layer.rb

@@ -0,0 +1,46 @@
+module Noggin
+  class Layer
+
+    attr_accessor :origin_layer, :dest_layer, :neurons, :bias
+
+    def initialize
+      @neurons = []
+    end
+
+    def forward_activate!
+      @bias.forward_activate!
+      @neurons.each do |neuron|
+        neuron.forward_input = neuron.origins.inject(0){ |sum, edge| sum += edge.forward_output }
+        neuron.forward_activate!
+      end
+    end
+
+    def backward_activate!
+      @neurons.each do |neuron|
+        neuron.backward_input = neuron.dests.inject(0){ |sum, edge| sum += edge.backward_output }
+        neuron.backward_activate!
+      end
+    end
+
+    def biased
+      @bias = Bias.new if bias.nil?
+    end
+
+    class << self
+
+      def connect_layers origin_layer, dest_layer, momentum
+        dest_layer.biased
+        dest_layer.neurons.each do |dest_neuron|
+          Noggin::Neuron.connect_neurons dest_layer.bias, dest_neuron, momentum
+          origin_layer.neurons.each do |origin_neuron|
+            Noggin::Neuron.connect_neurons origin_neuron, dest_neuron, momentum
+          end
+        end
+        origin_layer.dest_layer = dest_layer
+        dest_layer.origin_layer = origin_layer
+      end
+
+    end
+
+  end
+end

data/lib/noggin/network.rb

@@ -1,118 +1,127 @@
 module Noggin
   class Network
 
-    attr_reader :input_nodes
-    attr_reader :output_node
-    attr_reader :layers
-    attr_reader :options
-
-    DEFAULTS = {
-        learning_rate: 0.3,
-        momentum: 5,
-        max_training_laps: 2000,
-        hidden_layer_size: 1,
-        hidden_layer_node_size: 2,
-        log: false
+    attr_accessor :layers, :options, :forward_input, :forward_output
+    
+     DEFAULTS = {
+      learning_rate: 0.3,
+      momentum: 1,
+      training_laps: 50000,
+      hidden_layer_size: 1,
+      hidden_layer_node_size: 2,
+      min_training_error: 0.001
     }
 
     def initialize **opts
       @options = DEFAULTS.merge opts
-      @ready = false
       @layers = []
+      @ready = false
     end
 
-    def run input
-      update_input_nodes input
-      output_node.output
-    end
-
-    def train data_batch
-      init_network(data_batch)unless @ready
-      options[:max_training_laps].times do |i|
-        data_batch.each do |batch|
-          propagate_error! batch[:input], batch[:output]
-          if options[:log] && i == options[:max_training_laps] - 1
-            print "Last train for input: #{batch[:input]}, expected: #{batch[:output]}"
-            pretty_print
-          end
+    def train data_set
+      @forward_input = data_set
+      setup_layers unless @ready
+      error = Float::INFINITY
+      laps = 0
+      until laps >= options[:training_laps] || error < options[:min_training_error] do
+        laps += 1
+        error = 0
+        data_set.each do |set|
+          setup_input set[:input]
+          setup_expected set[:expected]
+          error += run_for_error set[:input]
+          setup_backwards
+          run_backwards
+          update_weights
         end
       end
-      return self
+      { total_error: error, training_laps_needed: laps }
     end
 
-    def propagate_error! input, expected
-      update_input_nodes input
-      output_node.expected = expected
-      input_nodes.each { |node| node.derivative_chain }
-      update_weights!
+    def run input
+      setup_input input
+      run_forwards input
+      layers.last.neurons.first.forward_output
     end
 
-    def update_weights!
-      edges.each do |edge|
-        delta_weight = options[:learning_rate] * edge.derivative
-        edge.weight -= delta_weight + (edge.momentum * edge.previous_weight)
-        edge.previous_weight = delta_weight
-      end
+    def run_for_error input
+      run_forwards input
+      layers.last.neurons.inject(0){ |sum, neuron| sum += neuron.forward_error_output }
     end
 
-    def init_network data_batch
-      @input_nodes = Array.new(data_batch.first[:input].size + 1){ Noggin::Node::Input.new }
-      @layers << @input_nodes
-      last_layer = @input_nodes
-      options[:hidden_layer_size].times do |i|
-        new_layer = Array.new(options[:hidden_layer_node_size]){ Noggin::Node::Base.new }
-        bias_node = Noggin::Node::Input.new
-        bias_node.output = 1
-        new_layer << bias_node
-        @layers << new_layer
-        connect_layer last_layer, new_layer
-        last_layer = new_layer
+    def run_forwards input
+      layers[1..-1].each(&:forward_activate!)
+    end
+
+    def run_backwards
+      layers.reverse[1..-1].each(&:backward_activate!)
+    end
+
+    def update_weights
+      layers.each do |layer|
+        layer.bias.learn! if layer.bias
+        layer.neurons.each do |neuron|
+          neuron.dests.each(&:learn!)
+        end
       end
-      @output_node = Noggin::Node::Output.new
-      @layers << [@output_node]
-      last_layer.each { |node| connect_nodes(node, output_node) }
+    end
+
+    def setup_layers
+      setup_input_layer
+      setup_hidden_layers
+      setup_output_layer
       @ready = true
     end
 
-    def edges
-      edges = []
-      queue = [output_node]
-      while queue.size != 0 do
-        node = queue.pop
-        node.origins.each do |edge|
-          edges << edge
-          queue << edge.origin
-        end
+    def setup_input_layer
+      input_layer = Layer.new
+      input_layer.neurons = Array.new(input_set_size){ Noggin::Neuron.new }
+      layers << input_layer
+    end
+
+    def setup_hidden_layers
+      options[:hidden_layer_size].times do |i|
+        hidden_layer = Layer.new
+        hidden_layer.neurons = Array.new(options[:hidden_layer_node_size]){ Noggin::Neuron.new }
+        Noggin::Layer.connect_layers layers.last, hidden_layer, options[:momentum]
+        layers << hidden_layer
       end
-      edges
     end
 
-    def connect_nodes origin, dest
-      edge = Noggin::Node::Edge.new origin: origin, dest: dest, momentum: options[:momentum]
-      origin.dests << edge
-      dest.origins << edge
+    def setup_output_layer
+      output_layer = Layer.new
+      output_layer.neurons = [ Noggin::Neuron.new ]
+      Noggin::Layer.connect_layers layers.last, output_layer, options[:momentum]
+      layers << output_layer
     end
 
-    def connect_layer origins, dests
-      origins.each do |origin|
-        dests.each do |dest|
-          connect_nodes origin, dest
+    def setup_input set
+      layers.first.neurons.each_with_index do |neuron, i|
+        neuron.forward_input = neuron.forward_output = set[i]
+        neuron.dests.each do |edge|
+          edge.forward_input = neuron.forward_output
+          edge.forward_activate!
         end
       end
     end
 
-    def update_input_nodes input
-      input_nodes.each_with_index do | node, i |
-        if i == (input.size)
-          node.output = 1
-        else
-          node.output = input[i]
-        end
+    def setup_backwards
+      layers.last.neurons.each do |output_neuron|
+        output_neuron.backward_activate_error!
+        output_neuron.backward_activate!
       end
     end
 
+    def setup_expected expected
+      layers.last.neurons.each { |neuron| neuron.expected = expected }
+    end
+
+    def input_set_size
+      forward_input.first[:input].size
+    end
+
     def pretty_print
-       Noggin::PrettyPrinter.print_network layers
+      Noggin::PrettyPrinter.print_network self
     end
 
   end

data/lib/noggin/neuron.rb

@@ -0,0 +1,47 @@
+module Noggin
+  class Neuron
+
+    attr_accessor :origins, :dests, :derivative, :expected, :forward_input, :forward_output, :forward_error_output,
+                  :backward_input, :backward_output, :backward_error_output
+    
+    def initialize
+      @origins = []
+      @dests = []
+    end
+
+    def forward_activate!
+      @forward_output = 1 / ( 1 + Math.exp(-1 * forward_input) )
+      dests.each do |edge|
+        edge.forward_input = @forward_output
+        edge.forward_activate!
+      end
+      forward_activate_error! unless @expected.nil?
+    end
+
+    def backward_activate!
+      @backward_output = @forward_output * ( 1 - @forward_output ) * @backward_input
+      origins.each do |edge|
+        edge.backward_input = @backward_output
+        edge.backward_activate!
+      end
+    end
+
+    def forward_activate_error!
+      @forward_error_output = 0.5 * (@expected - @forward_output)**2
+    end
+
+    def backward_activate_error!
+      @backward_error_output = @forward_output - @expected
+      @backward_input = @backward_error_output
+    end
+
+    class << self
+      def connect_neurons origin, dest, momentum
+        edge = Noggin::Edge.new origin: origin, dest: dest, momentum: momentum
+        origin.dests << edge
+        dest.origins << edge
+      end
+    end
+      
+  end
+end

data/lib/noggin/version.rb

@@ -1,3 +1,3 @@
 module Noggin
-  VERSION = '0.0.4'
+  VERSION = '0.1.0'
 end

data/spec/network_spec.rb

@@ -1,55 +1,155 @@
 require_relative '../lib/noggin'
 
-describe Noggin::Network do 
+describe :calculations do
+
+  MOCK_WEIGHT = 0.66
+
+  subject { Noggin::Network.new hidden_layer_node_size: 2, training_laps: 1 }
+
+  let(:input_neuron_one) { subject.layers[0].neurons[0] }
+
+  let(:input_neuron_two) { subject.layers[0].neurons[1] }
+
+  let(:hidden_bias) { subject.layers[1].bias }
+
+  let(:hidden_neuron_one) { subject.layers[1].neurons[0] }
+
+  let(:hidden_neuron_two) { subject.layers[1].neurons[1] }
+
+  let(:output_bias) { subject.layers[2].bias }
+
+  let(:output_neuron) { subject.layers[2].neurons[0] }
+
+  let(:input_neuron_one_edge_one) { input_neuron_one.dests[0] }
+
+  let(:input_neuron_one_edge_two) { input_neuron_one.dests[1] }
+
+  let(:input_neuron_two_edge_one) { input_neuron_two.dests[0] }
+
+  let(:input_neuron_two_edge_two) { input_neuron_two.dests[1] }
+
+  let(:hidden_neuron_one_edge_one) { hidden_neuron_one.dests[0] }
+
+  let(:hidden_neuron_two_edge_one) { hidden_neuron_two.dests[0] }
+
+  let(:hidden_bias_edge_one) { hidden_bias.dests[0] }
+
+  let(:hidden_bias_edge_two) { hidden_bias.dests[1] }
+
+  let(:output_bias_edge_one) { output_bias.dests[0] }
 
-  subject { Noggin::Network.new( max_training_laps: 1, learning_rate: 0.1, hidden_layer_size: 1, hidden_layer_node_size: 1 ) }
 
-  let(:input_node) { subject.layers[0].first }
-  let(:hidden_node) { subject.layers[1].first }
-  let(:output_node) { subject.layers[2].first }
-    
   before do
-    allow_any_instance_of(Noggin::Node::Edge).to receive(:weight).and_return(0.66)
-    subject.train [{ input: [1], output: 0 }]
-  end
 
-  it 'sets up the network graph according to settings' do
-    expect(input_node.dests.first.dest).to eq hidden_node
-    expect(hidden_node.dests.first.dest).to eq output_node
-  end
+    allow_any_instance_of(Noggin::Edge).to receive(:weight).and_return(MOCK_WEIGHT)
 
-  it 'sets hidden layer size' do
-    expect(subject.layers.size).to eq(3)
-  end
+    subject.train( [{ input: [1,0], expected: 0.2 }] )
 
-  it 'sets hidden layer node size' do
-    expect(subject.layers[1].size).to eq(2)
   end
 
-  it 'backpropagates error' do
-    expect(input_node.dests.first.derivative).to be_within(0.00001).of(0.015098)
-    expect(hidden_node.dests.first.derivative).to be_within(0.00001).of(0.10851)
+  describe 'forward' do
+
+    it 'forwards data correctly' do
+
+      expect(input_neuron_one.forward_output).to eq(1)
+      expect(input_neuron_two.forward_output).to eq(0)
+
+      expect(input_neuron_one_edge_one.forward_input).to eq(1)
+      expect(input_neuron_one_edge_two.forward_input).to eq(1)
+      expect(input_neuron_two_edge_one.forward_input).to eq(0)
+      expect(input_neuron_two_edge_two.forward_input).to eq(0)
+
+      expect(input_neuron_one_edge_one.forward_output).to eq(0.66)
+      expect(input_neuron_one_edge_two.forward_output).to eq(0.66)
+      expect(input_neuron_two_edge_one.forward_output).to eq(0)
+      expect(input_neuron_two_edge_two.forward_output).to eq(0)
+
+      expect(hidden_neuron_one.forward_input).to be_within(0.001).of(1.3200)
+      expect(hidden_neuron_two.forward_input).to be_within(0.001).of(1.3200)
+
+      expect(hidden_neuron_one.forward_output).to be_within(0.001).of(0.7892)
+      expect(hidden_neuron_two.forward_output).to be_within(0.001).of(0.7892)
+
+      expect(hidden_neuron_one_edge_one.forward_input).to be_within(0.001).of(0.7892)
+      expect(hidden_neuron_two_edge_one.forward_input).to be_within(0.001).of(0.7892)
+
+      expect(hidden_neuron_one_edge_one.forward_output).to be_within(0.0001).of(0.5208)
+      expect(hidden_neuron_two_edge_one.forward_output).to be_within(0.0001).of(0.5208)
+
+      expect(output_neuron.forward_input).to be_within(0.001).of(1.7017)
+      expect(output_neuron.forward_output).to be_within(0.001).of(0.8458)
+      expect(output_neuron.forward_error_output).to be_within(0.001).of(0.2085)
+
+    end
+
+    it 'backwards data correctly' do
+
+      expect(output_neuron.backward_error_output).to be_within(0.001).of(0.6458)
+      expect(output_neuron.backward_input).to be_within(0.001).of(0.6458)
+      expect(output_neuron.backward_output).to be_within(0.001).of(0.0842)
+
+      expect(output_bias_edge_one.backward_input).to be_within(0.001).of(0.0842)
+      expect(output_bias_edge_one.derivative).to be_within(0.001).of(0.0842)
+
+      expect(hidden_neuron_one_edge_one.backward_input).to be_within(0.001).of(0.0842)
+      expect(hidden_neuron_two_edge_one.backward_input).to be_within(0.001).of(0.0842)
+
+      expect(hidden_neuron_one_edge_one.backward_output).to be_within(0.001).of(0.0556)
+      expect(hidden_neuron_two_edge_one.backward_output).to be_within(0.001).of(0.0556)
+
+      expect(hidden_neuron_one_edge_one.derivative).to be_within(0.001).of(0.0664)
+      expect(hidden_neuron_two_edge_one.derivative).to be_within(0.001).of(0.0664)
+
+      expect(hidden_neuron_one.backward_input).to be_within(0.0001).of(0.0556)
+      expect(hidden_neuron_two.backward_input).to be_within(0.0001).of(0.0556)
+
+      expect(hidden_neuron_one.backward_output).to be_within(0.001).of(0.0092)
+      expect(hidden_neuron_two.backward_output).to be_within(0.001).of(0.0092)
+
+      expect(hidden_bias_edge_one.backward_input).to be_within(0.001).of(0.0092)
+      expect(hidden_bias_edge_one.derivative).to be_within(0.001).of(0.0092)
+      expect(hidden_bias_edge_two.backward_input).to be_within(0.001).of(0.0092)
+      expect(hidden_bias_edge_two.derivative).to be_within(0.001).of(0.0092)
+
+      expect(input_neuron_one_edge_one.backward_input).to be_within(0.001).of(0.0092)
+      expect(input_neuron_one_edge_two.backward_input).to be_within(0.001).of(0.0092)
+      expect(input_neuron_two_edge_one.backward_input).to be_within(0.001).of(0.0092)
+      expect(input_neuron_two_edge_two.backward_input).to be_within(0.001).of(0.0092)
+
+      expect(input_neuron_one_edge_one.backward_output).to be_within(0.001).of(0.0061)
+      expect(input_neuron_one_edge_two.backward_output).to be_within(0.0001).of(0.0061)
+      expect(input_neuron_two_edge_one.backward_output).to be_within(0.0001).of(0.0061)
+      expect(input_neuron_two_edge_two.backward_output).to be_within(0.0001).of(0.0061)
+
+      expect(input_neuron_one_edge_one.derivative).to be_within(0.001).of(0.0093)
+      expect(input_neuron_one_edge_two.derivative).to be_within(0.001).of(0.0093)
+      expect(input_neuron_two_edge_one.derivative).to be_within(0.01).of(0.0)
+      expect(input_neuron_two_edge_two.derivative).to be_within(0.01).of(0.0)
+
+    end
+
   end
 
 end
 
-
 describe :xor do
 
-  subject { Noggin::Network.new( max_training_laps: 2000, learning_rate: 0.3, hidden_layer_size: 1, hidden_layer_node_size: 2, momentum: 5, log: true ) }
-
+  subject { Noggin::Network.new training_laps: 20000}
 
   before do
     subject.train([
-      { input: [0, 0], output: 0 },
-      { input: [0, 1], output: 1 },
-      { input: [1, 0], output: 1 },
-      { input: [1, 1], output: 0 }
+      { input: [0, 0], expected: 0 },
+      { input: [0, 1], expected: 1 },
+      { input: [1, 0], expected: 1 },
+      { input: [1, 1], expected: 0 }
     ])
   end
 
-  it 'learns xor' do
-   
+  it 'learns' do
+    expect(subject.run([0,1])).to be_within(0.05).of(1.0)
+    expect(subject.run([1,1])).to be_within(0.05).of(0.0)
+    expect(subject.run([0,0])).to be_within(0.05).of(0.0)
+    expect(subject.run([1,0])).to be_within(0.05).of(1.0)
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: the_noggin
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Shawn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-23 00:00:00.000000000 Z
+date: 2015-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,12 +66,11 @@ files:
 - README.md
 - Rakefile
 - lib/noggin.rb
+- lib/noggin/bias.rb
+- lib/noggin/edge.rb
+- lib/noggin/layer.rb
 - lib/noggin/network.rb
-- lib/noggin/node/base.rb
-- lib/noggin/node/edge.rb
-- lib/noggin/node/input.rb
-- lib/noggin/node/output.rb
-- lib/noggin/pretty_printer.rb
+- lib/noggin/neuron.rb
 - lib/noggin/version.rb
 - noggin.gemspec
 - spec/network_spec.rb

data/lib/noggin/node/base.rb

@@ -1,44 +0,0 @@
-module Noggin
-  module Node
-    class Base
-
-      attr_reader :origins
-      attr_reader :dests
-      attr_accessor :derivative
-      attr_accessor :cached_input
-      attr_accessor :cached_output
-
-      def initialize
-        @origins = []
-        @dests = []
-      end
-
-      def input
-        origins.inject(0) { |sum, edge | sum += edge.value }
-      end
-
-      def output
-        1 / ( 1 + Math.exp(-1 * input) )
-      end
-
-      def output_derivative
-        output * (1 - output)
-      end
-
-      def derivative_chain
-        derivative = output_derivative * dests.inject(0) { |sum, edge| sum += edge.derivative_chain }
-      end
-
-      def pretty_print
-        out = []
-        out << " ------"
-        dests.each do |edge|
-          out << "|      | -EDGE--(#{edge.pretty_print}) "
-        end
-        out << " ------"
-        out
-      end
-
-    end
-  end
-end

data/lib/noggin/node/edge.rb

@@ -1,40 +0,0 @@
-module Noggin
-  module Node
-    class Edge
-
-      attr_accessor :origin
-      attr_accessor :dest
-      attr_accessor :weight
-      attr_accessor :previous_weight
-      attr_accessor :derivative
-      attr_accessor :momentum
-
-      def initialize origin: origin, dest: dest, weight: rand(0.20...0.80), momentum: 0.1
-        @origin = origin
-        @dest = dest
-        @weight = weight
-        @momentum = momentum
-        @previous_weight = 0
-      end
-
-      def input
-        origin.output
-      end
-
-      def value
-        origin.output * weight
-      end
-
-      def derivative_chain
-        derivative_chain = dest.derivative_chain
-        @derivative = input * derivative_chain
-        weight * derivative_chain
-      end
-
-      def pretty_print
-        "w: #{weight.round(6)}, d: #{derivative.round(6)}"
-      end
-
-    end
-  end
-end

data/lib/noggin/node/input.rb

@@ -1,7 +0,0 @@
-module Noggin
-  module Node
-    class Input < Noggin::Node::Base
-      attr_accessor :output
-    end
-  end
-end

data/lib/noggin/node/output.rb

@@ -1,31 +0,0 @@
-module Noggin
-  module Node
-    class Output < Noggin::Node::Base
-
-      attr_accessor :expected
-
-      def error
-        0.5 * (expected - output)**2
-      end
-
-      def error_derivative
-        output - expected
-      end
-
-      def derivative_chain
-        output_derivative * error_derivative
-      end
-
-      def pretty_print
-        out = []
-        out << " --------------"
-        out << "| ed: #{error_derivative.round(6)}"
-        out << "| d: #{derivative_chain.round(6)}"
-        out << "| e: #{error.round(6)}"
-        out << "| o: #{output.round(6)}"
-        out << " --------------"
-        out
-      end
-    end
-  end
-end

data/lib/noggin/pretty_printer.rb

@@ -1,27 +0,0 @@
-module Noggin
-  class PrettyPrinter
-    def self.print_network layers
-      print "\n"
-      grid = []
-      layers.each do |layer|
-        grid << col = []
-        layer.each do |node|
-          col << node.pretty_print
-        end
-        col.flatten!
-      end
-      grid[0].zip(*grid[1..-1]).each do |row|
-        row.each_with_index do |cell, col_i|
-          max_length = grid[col_i].max_by{|s| s.size }.size
-          if cell
-            room = max_length - cell.length
-            print cell
-            print " " * room
-            print "      "
-          end
-        end
-        print "\n"
-      end
-    end
-  end
-end