simple_neural_network 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4ddf41db0522abafd12d51c425246499522c36cd
+  data.tar.gz: 4b576ca87629cd9d98845b3d02c2c41e0a700cf1
+SHA512:
+  metadata.gz: d11cff2d470e190617dc1ed71b3db48d6585b65b728e9c6490dcc4711535febc34c16130461bfedc1c871b63938906685c36ca34aef2e7882067eb5fdbff17ef
+  data.tar.gz: 6e69176cc45847c10af9d662d70964ca0ff5e868bc1a7dff32ff6ff7f9b0fc1cec62dfd6567f10206f33b5b7a951fc7e30e7a55aa7f7ec86b133c956f370b633

data/lib/layer.rb

@@ -0,0 +1,74 @@
+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
+
+      @prev_layer = nil
+      @next_layer = nil
+
+      populate_neurons
+    end
+
+    # The method that drives network output resolution.
+    # get_output calculates the array of neuron values for this layer.
+    # This is calculated by recursively fetching the output from the previous layer, then applying edge/node weight and bias 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,154 @@
+require_relative "layer"
+require 'json'
+
+# 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)
+
+# Sample usage:
+#
+# network = SimpleNeuralNetwork::Network.new
+#
+# network.create_layer(neurons: 10)
+# network.create_layer(neurons: 2)
+
+# network.run([0.5]*10)
+
+class SimpleNeuralNetwork
+  class Network
+    class InvalidInputError < StandardError; end
+    # An array of layers
+    attr_accessor :layers
+
+    attr_accessor :inputs
+
+    attr_writer :normalization_function
+
+    attr_accessor :edge_initialization_function
+    attr_accessor :neuron_bias_initialization_function
+
+    def initialize
+      @layers = []
+      @inputs = []
+
+      @normalization_function = method(:default_normalization_function)
+      @edge_initialization_function = method(:default_edge_initialization_function)
+      @neuron_bias_initialization_function = method(:default_neuron_bias_initialization_function)
+    end
+
+    # Run an input set against the neural network.
+    # Accepts an array of input integers between 0 and 1
+    # Input array length must be equal to the size of the first layer.
+    # Returns an array of outputs.
+    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.map do |output|
+        @normalization_function.call(output)
+      end
+    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
+
+        prev_layer.initialize_neuron_edges
+      else
+        @layers << Layer.new(neurons, self)
+      end
+    end
+
+    def reset_normalization_function
+      @normalization_function = method(:default_normalization_function)
+    end
+
+    # Serializes the neural network into a JSON string. This can later be deserialized back into a Network object
+    # Useful for storing partially trained neural networks.
+    # Note: Currently does not serialize bias init function, edge init function, or normalization function
+    def serialize
+      {
+        layers: layers.map do |layer|
+          {
+            neurons: layer.neurons.map do |neuron|
+              {
+                bias: neuron.bias.to_f,
+                edges: neuron.edges.map(&:to_f)
+              }
+            end
+          }
+        end
+      }.to_json
+    end
+
+    # Deserialize a JSON neural network back into a Ruby object
+    # Note that the normalization function will need to be reset.
+    # Normalization function serialization in the future would be cool.
+    def self.deserialize(string)
+      hash = JSON.parse(string)
+
+      network = Network.new
+
+      hash["layers"].each do |layer|
+        neurons_array = layer["neurons"]
+        layer = Layer.new(neurons_array.length, network)
+        network.layers << layer
+
+        layer.neurons.each_with_index do |neuron, index|
+          neuron_hash = neurons_array[index]
+
+          neuron.bias = neuron_hash["bias"].to_f
+          neuron.edges = neuron_hash["edges"].map(&:to_f)
+        end
+      end
+
+      network.layers.each_with_index do |layer, index|
+        unless index == 0
+          layer.prev_layer = network.layers[index - 1]
+        end
+
+        layer.next_layer = network.layers[index + 1]
+      end
+
+      network
+    end
+
+    private
+
+    # The default normalization function for the network output
+    # The standard logistic sigmoid function
+    # f(x) = 1 / (1 + e^(-x))
+    def default_normalization_function(output)
+      1 / (1 + (Math::E ** (-1 * output)))
+    end
+
+    def default_edge_initialization_function
+      rand(-5..5)
+    end
+
+    def default_neuron_bias_initialization_function
+      0
+    end
+  end
+end

data/lib/neuron.rb

@@ -0,0 +1,23 @@
+class SimpleNeuralNetwork
+  class Neuron
+    attr_accessor :bias
+
+    # 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 = layer.network.neuron_bias_initialization_function.call
+      @edges = []
+    end
+
+    # A neuron should have one edge per neuron in the next layer
+    def initialize_edges(next_layer_size)
+      init_function = @layer.network.edge_initialization_function
+
+      next_layer_size.times do
+        @edges << init_function.call
+      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: simple_neural_network
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nathaniel Woodthorpe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-11 00:00:00.000000000 Z
+dependencies: []
+description: A 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 simple neural network implementation in Ruby.
+test_files: []