SimpleNeuralNetwork 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 46f5556f65b4606a5e8314e7ba7791f73ba314fd
+  data.tar.gz: 72fdae81f4c25de9f57bf4295f064d414dcd5380
+SHA512:
+  metadata.gz: 7149124f6817e608bba4ad2f9ca8419bbf50c27991fc1565b59f0f42cb8b2d1bdfa17fb4ad3bfeb4c41055eb19b7bec0b22e30361ead91c4c3251c4fb9a2c92a
+  data.tar.gz: 73e138bd6e0b474fcf57e576a884a407fe6512f2e0ae66ed8ab8ae2c22143247ac6b24aae5c2c409d3e19a83d3ea41075d71745b96c2ed34f9d5b5a31b4f9d35

data/lib/layer.rb

@@ -0,0 +1,71 @@
+require_relative "neuron"
+
+class SimpleNeuralNetwork
+  class Layer
+    # Number of neurons
+    attr_accessor :size
+
+    attr_accessor :prev_layer
+    attr_accessor :next_layer
+
+    # List of #{size} neurons
+    attr_accessor :neurons
+
+    attr_accessor :network
+
+    def initialize(size, network)
+      @size = size
+      @neurons = []
+      @network = network
+
+      populate_neurons
+    end
+
+    # The method that drives network output resolution.
+    # get_output calculates the array of node values for this layer.
+    # This is calculated by recursively fetching the output from the previous layer, then applying edge/node weight rules.
+    # The first layer will fetch it's values from @network.inputs
+    def get_output
+      if !prev_layer
+        # This is the first layer, so the output set is simply the network input set
+        @network.inputs
+      else
+        # Each neuron output value is calculated by:
+        # output[i] = (
+        #                (prev_layer.neurons[0] * prev_layer.neurons[0].edges[i])
+        #              + (prev_layer.neurons[1] * prev_layer.neurons[1].edges[i])
+        #              + ...
+        #             ) + self.neurons[i].bias
+
+        prev_layer_output = prev_layer.get_output
+
+        # Generate the output values for the layer
+        (0..@size-1).map do |i|
+          value = 0
+
+          prev_layer_output.each_with_index do |output, index|
+            value += (output * prev_layer.neurons[index].edges[i])
+          end
+
+         value + @neurons[i].bias
+        end
+      end
+    end
+
+    def initialize_neuron_edges
+      return unless @next_layer
+
+      @neurons.each do |neuron|
+        neuron.initialize_edges(@next_layer.size)
+      end
+    end
+
+    private
+
+    def populate_neurons
+      @size.times do
+        @neurons << Neuron.new(layer: self)
+      end
+    end
+  end
+end

data/lib/network.rb

@@ -0,0 +1,78 @@
+require_relative "layer"
+
+# To properly initialze a network:
+#  - Initialize the new Network object
+#  - Create layers using Network#create_layer
+#    (This creates layers from left to right, input -> hidden layers -> output layer)
+#  - Call Network#initialize_edges to populate neuron edges in the network.
+#    This has to be done after creating all layers because the number of edges depends
+#    on the number on neurons in the next layer
+class SimpleNeuralNetwork
+  class Network
+    class InvalidInputError < StandardError; end
+    # An array of layers
+    attr_accessor :layers
+
+    attr_accessor :inputs
+
+    def initialize
+      @layers = []
+      @inputs = []
+    end
+
+    # Run an input set against the neural network.
+    # Accepts an array of input integers between 0 and 1 of length #input_size
+    # Returns
+    def run(inputs)
+      unless inputs.size == input_size && inputs.all? { |input| input >= 0 && input <= 1 }
+        raise InvalidInputError.new("Invalid input passed to Network#run")
+      end
+
+      @inputs = inputs
+
+      # Get output from last layer. It recursively depends on layers before it.
+      @layers[-1].get_output
+    end
+
+    # Returns the number of input nodes
+    def input_size
+      @layers[0].size
+    end
+
+    # Returns the number of output nodes
+    def output_size
+      @layers[-1].size
+    end
+
+    def create_layer(neurons:)
+      unless @layers.empty?
+        new_layer = Layer.new(neurons, self)
+        prev_layer = @layers.last
+
+        @layers << new_layer
+
+        new_layer.prev_layer = prev_layer
+        prev_layer.next_layer = new_layer
+      else
+        @layers << Layer.new(neurons, self)
+      end
+    end
+
+    # This traverses the network and initializes all neurons with edges
+    # Initializes with random weights between -5 and 5
+    def initialize_edges
+      @layers.each(&:initialize_neuron_edges)
+    end
+  end
+end
+
+# Sample usage:
+#
+# network = Network.new
+#
+# network.create_layer(neurons: 10)
+# network.create_layer(neurons: 2)
+
+# network.initialize_edges
+
+# network.run([0.5]*10)

data/lib/neuron.rb

@@ -0,0 +1,28 @@
+class SimpleNeuralNetwork
+  class Neuron
+    # Define the minimum and maximum edge weight
+    EDGE_RANGE = -5..5
+
+    attr_accessor :bias
+
+    # The neuron parent layer
+    attr_accessor :layer
+
+    # A neuron's edges connect it to the #{layer.next_layer.size} neurons of the next layer
+    attr_accessor :edges
+
+    def initialize(layer)
+      @layer = layer
+      @bias = 0
+      @edges = []
+      @value = nil
+    end
+
+    # A neuron should have one edge per neuron in the next layer
+    def initialize_edges(next_layer_size)
+      next_layer_size.times do
+        @edges << rand(EDGE_RANGE)
+      end
+    end
+  end
+end

data/lib/simple_neural_network.rb

@@ -0,0 +1,3 @@
+class SimpleNeuralNetwork
+  require "network"
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: SimpleNeuralNetwork
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nathaniel Woodthorpe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-20 00:00:00.000000000 Z
+dependencies: []
+description: A very simple neural network implementation in Ruby.
+email: njwoodthorpe@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/layer.rb
+- lib/network.rb
+- lib/neuron.rb
+- lib/simple_neural_network.rb
+homepage: https://github.com/d12/SimpleNeuralNetwork
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: A very simple neural network implementation in Ruby.
+test_files: []