rann 0.2.7 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b604698cf3630cf7056f4b10d5b1b301292074b4
-  data.tar.gz: a341f41f53c78db0f026948b7bad72ff04574e54
+  metadata.gz: 2cd393e231a8a1da7a732eff0ea1e82008cc5dcc
+  data.tar.gz: 479d4669daab9e8f2fd60b06044d754e78479ad9
 SHA512:
-  metadata.gz: 3e7167b3fb0fb79d0fcd3fc7a72b59d0ab4c9d29b69e6fbc230599b11752b3b9e001c06e9bef284325974649e7f64d4f34dd05864fe1fedb9fa7786ef9d40586
-  data.tar.gz: 6816e982c0536c21a474e377c87ca6de213b62268dfda48317d2c360972e2fa2d0f32eb491c8a088cccae8ca3bb5ef367587d601db2a7eda3d45d695a6c5ea8a
+  metadata.gz: 55e2b084f9477543cdc8bbb3cd415e80bfd6c3f75517b61cd1969e9070aa2045c27a6003655394414414c11155cbf042aa597d8ef4798bdf4a2ffcfedd02782e
+  data.tar.gz: c2ca6ed22034d63d2a256d7a898b8c5c3c12fcf5674d133e34e405357740ca11ba2002ad26c5506e56b861349db42c8ede21bbc22ba57957bc447b515d4bdef1

data/CHANGES.md

@@ -1,3 +1,46 @@
+- More backprop fixes..
+
+  *Michael Campbell*
+
+- Give LSTM input neurons linear activation.
+
+  *Michael Campbell*
+
+- For context neurons connected to a product neuron, it's initial value should
+  be 1.
+
+  *Michael Campbell*
+
+- So. Many. Bugs. Turns out the product neuron stuff was still broken and
+  network evaluation wasn't behaving correctly with context neurons (recurrent
+  connections). Also an error in timestep handling during backprop, and just
+  generally network traversal ...
+
+  *Michael Campbell*
+
+- Don't lock the input connections into the LSTM layer, that acts as the fully
+  connected part of the network and that's where the majority of learning takes
+  place, derp.
+
+  *Michael Campbell*
+
+- Don't change the weight of a LockedConnection during initialisation. (eugh)
+
+  *Michael Campbell*
+
+- Fix bug in backprop over product neuron.
+
+  *Michael Campbell*
+
+- Worked out how to use BigDecimal properly, lol. Refactored to use
+  `BigDecimal.limit`.
+
+  *Michael Campbell*
+
+- Allow customisable precision, defaults to 10.
+
+  *Michael Campbell*
+
 ## 0.2.7 (December 2, 2017)
 
 - Allow different weights to the different gates in the LSTM. Previously it was

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rann (0.2.7)
+    rann (0.2.8)
       parallel (~> 1.12, >= 1.12.0)
       ruby-graphviz (~> 1.2, >= 1.2.3)
 

data/examples/step_by_step.rb

@@ -0,0 +1,57 @@
+# A reproduction of the wonderful step by step backprop example at
+# https://mattmazur.com/2015/03/17/a-step-by-step-backpropagation-example/
+
+require "bundler/setup"
+require "rann"
+
+# inputs
+inputs = Array.new(2){ |i| RANN::Neuron.new "input #{i}", 0, :input, :sig }
+
+# hidden layer
+hiddens = Array.new(2){ |i| RANN::Neuron.new "hidden #{i}", 3, :standard, :sig }
+hidden_bias = RANN::Neuron.new "bias", 0, :bias
+
+# output layer
+outputs = Array.new(2){ |i| RANN::Neuron.new "output #{i}", 3, :output, :sig }
+output_bias = RANN::Neuron.new "bias", 0, :bias
+
+# connect it all w/initial weights
+connections = []
+connections << RANN::Connection.new(inputs[0], hiddens[0], 0.15.to_d)
+connections << RANN::Connection.new(inputs[0], hiddens[1], 0.25.to_d)
+connections << RANN::Connection.new(inputs[1], hiddens[0], 0.2.to_d)
+connections << RANN::Connection.new(inputs[1], hiddens[1], 0.3.to_d)
+connections << RANN::Connection.new(hidden_bias, hiddens[0], 0.35.to_d)
+connections << RANN::Connection.new(hidden_bias, hiddens[1], 0.35.to_d)
+
+connections << RANN::Connection.new(hiddens[0], outputs[0], 0.4.to_d)
+connections << RANN::Connection.new(hiddens[0], outputs[1], 0.5.to_d)
+connections << RANN::Connection.new(hiddens[1], outputs[0], 0.45.to_d)
+connections << RANN::Connection.new(hiddens[1], outputs[1], 0.55.to_d)
+connections << RANN::Connection.new(output_bias, outputs[0], 0.6.to_d)
+connections << RANN::Connection.new(output_bias, outputs[1], 0.6.to_d)
+
+network = RANN::Network.new connections
+backprop = RANN::Backprop.new network
+
+inputs = [0.05.to_d, 0.10.to_d]
+targets = [0.1.to_d, 0.99.to_d]
+outputs = network.evaluate [0.05.to_d, 0.10.to_d]
+
+puts "forward prop outputs: #{outputs.map(&:to_f).inspect}"
+
+network.reset!
+
+gradients, error =
+  RANN::Backprop.run_single(
+    network,
+    [0.05.to_d, 0.10.to_d],
+    [0.01.to_d, 0.99.to_d]
+  )
+
+puts "error: #{error.to_f}"
+puts "backprop gradients & updates:"
+gradients.each do |cid, g|
+  c = network.connections.find{ |c| c.id == cid }
+  puts "#{c.input_neuron.name} -> #{c.output_neuron.name}: g = #{g.to_f}, u = #{(c.weight - 0.5.to_d * g).to_f}"
+end

data/lib/rann.rb

@@ -7,3 +7,6 @@ require "rann/product_neuron"
 require "rann/connection"
 require "rann/locked_connection"
 require "rann/backprop"
+
+BigDecimal.mode BigDecimal::EXCEPTION_ALL, true
+BigDecimal.limit 10

data/lib/rann/backprop.rb

@@ -12,9 +12,9 @@ module RANN
 
     ACTIVATION_DERIVATIVES = {
       relu:   ->(x){ x > 0 ? 1.to_d : 0.to_d },
-      sig:    ->(x){ x.mult(1 - x, 10) },
+      sig:    ->(x){ x * (1 - x) },
       linear: ->(_){ 1.to_d },
-      tanh:   ->(x){ 1 - x.power(2, 10) },
+      tanh:   ->(x){ 1 - x ** 2 },
       step:   ->(_){ 0.to_d },
     }
 
@@ -60,9 +60,9 @@ module RANN
           gradients, error = Backprop.run_single network, input, targets[i + j]
 
           gradients.each do |cid, g|
-            group_avg_gradients[cid] += g.div batch_size, 10
+            group_avg_gradients[cid] += g / batch_size
           end
-          group_avg_error += error.div batch_size, 10
+          group_avg_error += error / batch_size
         end
 
         group_avg_gradients.default_proc = nil
@@ -113,64 +113,80 @@ module RANN
       error = mse targets, outputs
 
       # backward pass with unravelling for recurrent networks
-      node_deltas = Hash.new{ |h, k| h[k] = Hash.new 0.to_d }
-      gradients = Hash.new 0.to_d
-
+      node_deltas = Hash.new{ |h, k| h[k] = {} }
       initial_timestep = inputs.size - 1
       neuron_stack = network.output_neurons.map{ |n| [n, initial_timestep] }
+      # initialize network end-point node_deltas in all timesteps with zero
+      network.neurons_with_no_outgoing_connections.each do |n|
+        (0...(inputs.size - 1)).each do |i|
+          node_deltas[i][n.id] = 0.to_d
+          neuron_stack << [n, i]
+        end
+      end
+      gradients = Hash.new 0.to_d
 
       while current = neuron_stack.shift
         neuron, timestep = current
         next if node_deltas[timestep].key? neuron.id
 
-        from_here = bptt_connecting_to neuron, network, timestep
-        neuron_stack.push *from_here
-
         # neuron delta is summation of neuron deltas deltas for the connections
         # from this neuron
-        step_one =
-          if neuron.output?
-            output_index = network.output_neurons.index neuron
-            mse_delta targets[output_index], outputs[output_index]
-          else
+        if neuron.output?
+          output_index = network.output_neurons.index neuron
+          step_one = mse_delta targets[output_index], outputs[output_index]
+        else
+          sum =
             network.connections_from(neuron).reduce 0.to_d do |m, c|
               out_timestep = c.output_neuron.context? ? timestep + 1 : timestep
               output_node_delta = node_deltas[out_timestep][c.output_neuron.id]
 
-              # connection delta is the output neuron delta multiplied by the
-              # connection's weight
-              connection_delta =
-                if c.output_neuron.is_a? ProductNeuron
-                  intermediate = states[out_timestep][:intermediates][c.output_neuron.id]
-                  output_node_delta.mult intermediate.div(states[timestep][:values][c.input_neuron.id], 10), 10
-                else
-                  output_node_delta.mult c.weight, 10
-                end
-
-              m + connection_delta
+              if out_timestep > initial_timestep
+                m
+              elsif !output_node_delta
+                break
+              else
+                # connection delta is the output neuron delta multiplied by the
+                # connection's weight
+                connection_delta =
+                  if c.output_neuron.is_a? ProductNeuron
+                    intermediate =
+                      network.connections_to(c.output_neuron).reject{ |c2| c2 == c }.reduce 1.to_d do |m, c2|
+                        m * states[timestep][:values][c2.input_neuron.id] * c2.weight
+                      end
+                    output_node_delta * intermediate * c.weight
+                  else
+                    output_node_delta * c.weight
+                  end
+
+                m + connection_delta
+              end
             end
-          end
+
+          step_one = sum || next
+        end
+
+        from_here = bptt_connecting_to neuron, network, timestep
+        neuron_stack |= from_here
 
         node_delta =
           ACTIVATION_DERIVATIVES[neuron.activation_function]
-            .call(states[timestep][:values][neuron.id])
-            .mult(step_one, 10)
+            .call(states[timestep][:values][neuron.id]) *
+            step_one
 
         node_deltas[timestep][neuron.id] = node_delta
 
+        in_timestep = neuron.context? ? timestep - 1 : timestep
         network.connections_to(neuron).each do |c|
-          in_timestep = neuron.context? ? timestep - 1 : timestep
-
           # connection gradient is the output neuron delta multipled by the
           # connection's input neuron value.
           gradient =
             if c.output_neuron.is_a? ProductNeuron
               intermediate = states[timestep][:intermediates][c.output_neuron.id]
-              node_delta.mult intermediate.div(c.weight, 10), 10
+              node_delta * intermediate / c.weight
             elsif c.input_neuron.context? && timestep == 0
               0.to_d
             else
-              node_delta.mult states[in_timestep][:values][c.input_neuron.id], 10
+              node_delta * states[in_timestep][:values][c.input_neuron.id]
             end
 
           gradients[c.id] += gradient
@@ -192,7 +208,7 @@ module RANN
       end
     end
 
-    def restore filepath
+    def restore filepath = nil
       unless filepath
         filepath = Dir['*'].select{ |f| f =~ /rann_savepoint_.*/ }.sort.last
 
@@ -217,7 +233,7 @@ module RANN
       total_squared_error = 0.to_d
 
       targets.size.times do |i|
-        total_squared_error += (targets[i] - outputs[i]).power(2, 10).div(2, 10)
+        total_squared_error += (targets[i] - outputs[i]) ** 2 / 2
       end
 
       total_squared_error
@@ -231,11 +247,12 @@ module RANN
       # halt traversal if we're at a context and we're at the base timestep
       return [] if neuron.context? && timestep == 0
 
+      timestep -= 1 if neuron.context?
+
       network.connections_to(neuron).each.with_object [] do |c, a|
         # don't enqueue connections from inputs
         next if c.input_neuron.input?
 
-        timestep -= timestep if neuron.context?
         a << [c.input_neuron, timestep]
       end
     end

data/lib/rann/connection.rb

@@ -25,7 +25,7 @@ module RANN
 
     def process
       if processable? && !processed?
-        out_value = input_neuron.value.mult weight, 10
+        out_value = input_neuron.value * weight
         output_neuron.push_value! out_value
         @processed = true
       end
@@ -60,8 +60,9 @@ module RANN
       if output_neuron.context?
         1.to_d
       else
-        rand.to_d 10
+        rand.to_d BigDecimal.limit
       end
     end
   end
 end
+

data/lib/rann/gradient_checker.rb

@@ -1,15 +1,17 @@
 module RANN
   class GradientChecker
-    EPSILON = 10.to_d.power -4, 10
+    def self.epsilon
+      10.to_d ** -4
+    end
 
     def self.check network, inputs, targets, dvec
       gradapprox = []
 
       network.params.size.times do |i|
         thetaplus = network.params.dup
-        thetaplus[i] = thetaplus[i] + EPSILON
+        thetaplus[i] = thetaplus[i] + epsilon
         thetaminus = network.params.dup
-        thetaminus[i] = thetaminus[i] - EPSILON
+        thetaminus[i] = thetaminus[i] - epsilon
 
         network.impose thetaplus
         outputs = network.evaluate inputs
@@ -21,7 +23,7 @@ module RANN
         error_thetaminus = error outputs, targets
         network.reset!
 
-        gradapprox[i] = (error_thetaplus - error_thetaminus).div(EPSILON.mult(2, 10), 10)
+        gradapprox[i] = (error_thetaplus - error_thetaminus) / (epsilon * 2)
       end
 
       gradapprox.each.with_index.with_object [] do |(ga, i), res|
@@ -33,7 +35,7 @@ module RANN
       total_squared_error = 0.to_d
 
       targets.size.times do |i|
-        total_squared_error += (targets[i] - outputs[i]).power(2, 10).div(2, 10)
+        total_squared_error += (targets[i] - outputs[i]) ** 2 / 2
       end
 
       total_squared_error

data/lib/rann/lstm.rb

@@ -19,52 +19,46 @@ module RANN
 
     def init
       @size.times do |j|
-        input = RANN::Neuron.new("LSTM #{name} Input #{j}", 0, :standard).tap{ |n| @network.add n }
+        input = RANN::Neuron.new("LSTM #{name} Input #{j}", 0, :standard, :linear).tap{ |n| @network.add n }
         @inputs << input
 
         f = RANN::Neuron.new("LSTM #{name} F #{j}", 3, :standard, :sig).tap{ |n| @network.add n }
         i = RANN::Neuron.new("LSTM #{name} I #{j}", 4, :standard, :sig).tap{ |n| @network.add n }
         g = RANN::Neuron.new("LSTM #{name} G #{j}", 3, :standard, :tanh).tap{ |n| @network.add n }
         o = RANN::Neuron.new("LSTM #{name} O #{j}", 3, :standard, :sig).tap{ |n| @network.add n }
-        bias_f = RANN::Neuron.new("LSTM #{name} Bias F #{j}", 0, :bias).tap do |n|
-          @network.add n
-        end
-        bias_i = RANN::Neuron.new("LSTM #{name} Bias I #{j}", 0, :bias).tap do |n|
-          @network.add n
-        end
-        bias_g = RANN::Neuron.new("LSTM #{name} Bias G #{j}", 0, :bias).tap do |n|
-          @network.add n
-        end
-        bias_o = RANN::Neuron.new("LSTM #{name} Bias O #{j}", 0, :bias).tap do |n|
-          @network.add n
-        end
+        bias_f = RANN::Neuron.new("LSTM #{name} Bias F #{j}", 0, :bias).tap{ |n| @network.add n }
+        bias_i = RANN::Neuron.new("LSTM #{name} Bias I #{j}", 0, :bias).tap{ |n| @network.add n }
+        bias_g = RANN::Neuron.new("LSTM #{name} Bias G #{j}", 0, :bias).tap{ |n| @network.add n }
+        bias_o = RANN::Neuron.new("LSTM #{name} Bias O #{j}", 0, :bias).tap{ |n| @network.add n }
         memory_product = RANN::ProductNeuron.new("LSTM #{name} Mem Product #{j}", 2, :standard, :linear).tap{ |n| @network.add n }
         i_g_product = RANN::ProductNeuron.new("LSTM #{name} Hidden 2/3 Product #{j}", 2, :standard, :linear).tap{ |n| @network.add n }
         memory_standard = RANN::Neuron.new("LSTM #{name} Mem Standard #{j}", 2, :standard, :linear).tap{ |n| @network.add n }
         memory_tanh = RANN::Neuron.new("LSTM #{name} Mem Tanh #{j}", 1, :standard, :tanh).tap{ |n| @network.add n }
         memory_o_product = RANN::ProductNeuron.new("LSTM #{name} Mem/Hidden 4 Product #{j}", 2, :standard, :linear).tap{ |n| @network.add n }
-        output = RANN::Neuron.new("LSTM #{name} Output #{j}", 1, :standard, :linear).tap{ |n| @network.add n }
-        @outputs << output
-        memory_context = RANN::Neuron.new("LSTM #{name} Mem Context #{j}", 1, :context).tap{ |n| @network.add n }
+        @outputs << memory_o_product
+        memory_context =
+          RANN::Neuron.new("LSTM #{name} Mem Context #{j}", 1, :context).tap do |n|
+            @network.add n
+            n.value = 1.to_d # connecting to a product neuron
+          end
         output_context = RANN::Neuron.new("LSTM #{name} Output Context #{j}", 1, :context).tap{ |n| @network.add n }
 
         @network.add RANN::Connection.new input, f
         @network.add RANN::Connection.new input, i
         @network.add RANN::Connection.new input, g
         @network.add RANN::Connection.new input, o
-        @network.add RANN::LockedConnection.new f, memory_product, 1
-        @network.add RANN::LockedConnection.new i, i_g_product, 1
-        @network.add RANN::LockedConnection.new g, i_g_product, 1
-        @network.add RANN::LockedConnection.new i_g_product, memory_standard, 1
-        @network.add RANN::LockedConnection.new memory_product, memory_standard, 1
-        @network.add RANN::LockedConnection.new memory_standard, memory_tanh, 1
-        @network.add RANN::LockedConnection.new o, memory_o_product, 1
-        @network.add RANN::LockedConnection.new memory_tanh, memory_o_product, 1
-        @network.add RANN::LockedConnection.new memory_o_product, output, 1
-        @network.add RANN::LockedConnection.new memory_standard, memory_context, 1
-        @network.add RANN::LockedConnection.new memory_context, memory_product, 1
-        @network.add RANN::LockedConnection.new memory_context, i, 1
-        @network.add RANN::LockedConnection.new memory_o_product, output_context, 1
+        @network.add RANN::LockedConnection.new f, memory_product, 1.to_d
+        @network.add RANN::LockedConnection.new i, i_g_product, 1.to_d
+        @network.add RANN::LockedConnection.new g, i_g_product, 1.to_d
+        @network.add RANN::LockedConnection.new i_g_product, memory_standard, 1.to_d
+        @network.add RANN::LockedConnection.new memory_product, memory_standard, 1.to_d
+        @network.add RANN::LockedConnection.new memory_standard, memory_tanh, 1.to_d
+        @network.add RANN::LockedConnection.new o, memory_o_product, 1.to_d
+        @network.add RANN::LockedConnection.new memory_tanh, memory_o_product, 1.to_d
+        @network.add RANN::LockedConnection.new memory_standard, memory_context, 1.to_d
+        @network.add RANN::LockedConnection.new memory_context, memory_product, 1.to_d
+        @network.add RANN::LockedConnection.new memory_context, i, 1.to_d
+        @network.add RANN::LockedConnection.new memory_o_product, output_context, 1.to_d
         @network.add RANN::Connection.new output_context, f
         @network.add RANN::Connection.new output_context, i
         @network.add RANN::Connection.new output_context, g
@@ -78,7 +72,7 @@ module RANN
 
     def add_input neuron
       @inputs.each do |input|
-        @network.add RANN::LockedConnection.new neuron, input, 1
+        @network.add RANN::Connection.new neuron, input
       end
     end
   end

data/lib/rann/network.rb

@@ -41,7 +41,7 @@ module RANN
       # would probably be easier to detect circular dependency this way too?
       begin
         i = 0
-        until output_neurons.all?{ |neuron| neuron.value }
+        until connections.select(&:enabled?).all? &:processed?
           i += 1
           connections.each do |connection|
             next if !connection.enabled?
@@ -167,11 +167,15 @@ module RANN
 
     def init_normalised!
       connections.each do |c|
+        next if c.locked?
+
         out_cons = c.output_neuron.connection_count.to_d
-        from     = -1.to_d.div out_cons.sqrt(10), 10
-        to       = 1.to_d.div out_cons.sqrt(10), 10
-        c.weight = (to - from).mult(rand.to_d, 10) + from
+        from     = -1.to_d / out_cons.sqrt(0)
+        to       = 1.to_d / out_cons.sqrt(0)
+        c.weight = (to - from) * rand.to_d + from
       end
+
+      true
     end
     alias init_normalized! init_normalised!
 
@@ -179,6 +183,16 @@ module RANN
       neurons.each do |neuron|
         neuron.connection_count = connections.count{ |c| c.output_neuron == neuron }
       end
+
+      true
+    end
+
+    def neurons_with_no_outgoing_connections
+      return @no_outgoing if defined? @no_outgoing
+
+      neurons.select do |n|
+        connections_from(n).none?
+      end
     end
   end
 end

data/lib/rann/neuron.rb

@@ -1,12 +1,13 @@
 require "securerandom"
 require "bigdecimal"
+require "bigdecimal/math"
 require "bigdecimal/util"
 
 module RANN
   class Neuron
     ACTIVATION_FUNCTIONS = {
-      sig:    ->(v){ 1.to_d.div(1 + Math::E.to_d.power(-v, 10), 10) },
-      tanh:   ->(v){ Math.tanh(v).to_d(10) },
+      sig:    ->(v){ 1.to_d / (1 + BigMath.E(BigDecimal.limit) ** -v) },
+      tanh:   ->(v){ Math.tanh(v).to_d(BigDecimal.limit) },
       relu:   ->(v){ [0.to_d, v].max },
       linear: ->(v){ v },
       step:   ->(v){ v > 0.5 ? 1.to_d : 0.to_d },
@@ -73,7 +74,7 @@ module RANN
     end
 
     def initial_activation_function
-      if standard? || context?
+      if standard?
         :relu
       else
         :linear

data/lib/rann/optimisers/adagrad.rb

@@ -12,9 +12,9 @@ module RANN
       end
 
       def update grad, cid
-        @historical_gradient[cid] = @historical_gradient[cid] + grad.power(2, 10)
+        @historical_gradient[cid] = @historical_gradient[cid] + grad ** 2
 
-        grad.mult(- @learning_rate.div(@fudge_factor + @historical_gradient[cid].sqrt(10), 10), 10)
+        grad * - @learning_rate / (@fudge_factor + @historical_gradient[cid].sqrt(0))
       end
 
       # anything that gets modified over the course of training

data/lib/rann/optimisers/rmsprop.rb

@@ -13,9 +13,9 @@ module RANN
       end
 
       def update grad, cid
-        @historical_gradient[cid] = @decay.mult(@historical_gradient[cid], 10) + (1 - @decay).mult(grad.power(2, 10), 10)
+        @historical_gradient[cid] = @decay * @historical_gradient[cid] + (1 - @decay) * grad ** 2
 
-        grad.mult(- @learning_rate.div(@fudge_factor + @historical_gradient[cid].sqrt(10), 10), 10)
+        grad * - @learning_rate / (@fudge_factor + @historical_gradient[cid].sqrt(0))
       end
 
       # anything that gets modified over the course of training

data/lib/rann/product_neuron.rb

@@ -5,7 +5,7 @@ module RANN
     attr_accessor :intermediate
 
     def set_value!
-      @intermediate = incoming.reduce{ |i, m| m.mult(i, 10) }
+      @intermediate = incoming.reduce :*
       self.value    = ACTIVATION_FUNCTIONS[activation_function].call @intermediate
     end
   end

data/lib/rann/version.rb

@@ -1,3 +1,3 @@
 module RANN
-  VERSION = "0.2.7"
+  VERSION = "0.2.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rann
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - Michael Campbell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-02 00:00:00.000000000 Z
+date: 2017-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -110,6 +110,7 @@ files:
 - bench/xor_benchmark.rb
 - bin/console
 - bin/setup
+- examples/step_by_step.rb
 - examples/xor.rb
 - lib/rann.rb
 - lib/rann/backprop.rb