newral 0.1

data/lib/newral/graphs/a_star.rb

@@ -0,0 +1,12 @@
+module Newral
+  module Graphs
+    class AStar < TreeSearch 
+    
+     
+     def measure( path  )
+        path.cost + Newral::Tools.euclidian_distance( @end_node.location, path.end_node.location )
+     end
+
+    end
+  end 
+end 

data/lib/newral/graphs/cheapest_first.rb

@@ -0,0 +1,11 @@
+module Newral
+  module Graphs
+    class CheapestFirst < TreeSearch 
+    
+     def measure( path  )
+        path.cost 
+     end
+
+    end
+  end 
+end 

data/lib/newral/graphs/edge.rb

@@ -0,0 +1,24 @@
+module Newral
+  module Graphs
+    class Edge
+      attr_accessor :start_node, :end_node, :directed, :cost, :data
+      def initialize( key:nil, start_node: nil, end_node: nil, directed: false, cost: nil, data:nil )
+        @key = key
+        @start_node = start_node
+        @end_node = end_node
+        @directed = directed
+        @cost = cost
+        @data = data
+        
+      end
+
+      def key 
+        @key || "#{ @start_node }#{ directed ? '=>' : '<=>' }#{ @end_node }"
+      end
+
+      def to_s 
+        key
+      end 
+    end
+  end
+end

data/lib/newral/graphs/graph.rb

@@ -0,0 +1,63 @@
+module Newral
+  module Graphs
+    module Errors 
+      class UnknownNode < StandardError; end
+    end 
+    class Graph
+      attr_reader :nodes, :edges
+      def initialize( nodes: [], edges: [] )
+        @nodes = nodes
+        @edges = edges
+      end
+      
+      def add_edge( edge )
+        unless @nodes.member?( edge.start_node ) && @nodes.member?( edge.end_node )
+          # let´s try to find it 
+          @nodes.each do |node|
+            edge.start_node = node if node.respond_to?( :name ) && node.name == edge.start_node
+            edge.end_node = node if node.respond_to?( :name ) && node.name == edge.end_node
+          end 
+          raise Errors::UnkownNode unless @nodes.member?( edge.start_node ) && @nodes.member?( edge.end_node )
+        end
+        @edges << edge 
+        self
+      end 
+
+      def add_node( node )
+        @nodes < node 
+        self
+      end
+
+      def add_nodes( nodes )
+        @nodes = @nodes+nodes
+        self
+      end
+
+      def find_node_by_name( name )
+        @nodes.find{ |node| node.name == name }
+      end
+
+      # we can add also like this {1=> 2, 2 => 5 }
+      def add_edges( edges, directed: false )
+        if edges.kind_of?( Hash )
+          edges.each do |from,to|
+            @edges << Edge.new( start_node: from, end_node: to, directed: directed )
+          end 
+        else 
+          edges.each do |edge|
+            add_edge edge
+          end
+        end
+        self
+      end
+
+      def find_edges( node )
+        @edges.collect do |edge| 
+          keep = edge.directed ? edge.start_node == node : edge.start_node == node || edge.end_node == node
+          edge if keep
+        end.compact
+      end 
+
+    end 
+  end
+end

data/lib/newral/graphs/node.rb

@@ -0,0 +1,11 @@
+module Newral
+  module Graphs
+    class Node 
+      attr_reader :name, :location
+      def initialize( name: nil, location: nil )
+        @name = name
+        @location = location
+      end
+    end 
+  end
+end

data/lib/newral/graphs/path.rb

@@ -0,0 +1,50 @@
+module Newral
+  module Graphs
+    module Errors 
+      class CanOnlyConnectToLastEdge < ::StandardError; end 
+      class CircularPath < ::StandardError; end 
+    end 
+
+    class Path
+      attr_reader :edges
+      def initialize( edges:[], allow_circular_paths: true )
+        @edges = edges.dup
+        @allow_circular_paths = allow_circular_paths
+      end
+
+      def add_edge( edge )
+        last_edge = @edges.last 
+        raise Errors::CanOnlyConnectToLastEdge,[last_edge,edge] unless  @edges.empty? || last_edge.end_node == edge.start_node 
+        raise Errors::CircularPath unless @allow_circular_paths && !@edges.index{|edge1| edge1.start_node == edge.end_node || edge1.end_node == edge.end_node }
+        @edges << edge   
+        self  
+      end
+
+      def length 
+        @edges.length 
+      end 
+
+      def cost 
+        @edges.inject(0){ |value,edge| value+edge.cost }
+      end 
+
+
+      def start_node
+        @edges.first.start_node
+      end 
+
+
+      def end_node
+        @edges.last.end_node
+      end 
+
+      def to_s
+        @edges.join(', ')
+      end
+
+    
+      
+  
+    end
+  end
+end

data/lib/newral/graphs/tree_search.rb

@@ -0,0 +1,60 @@
+module Newral
+  module Graphs
+    module Errors 
+      class FrontierEmpty < StandardError; end
+    end 
+    # the algorithms are heavily inspired by the Udacity course from
+    # Sebastian Thrun https://classroom.udacity.com/courses/cs271
+    class TreeSearch 
+      attr_reader :frontier
+      def initialize( graph: nil, start_node: nil, end_node: nil  )
+        @graph = graph 
+        @start_node = start_node
+        @end_node = end_node 
+        path = Path.new(edges:[ Edge.new( start_node: start_node, end_node: start_node, directed: true, cost:0 )])
+        @explored = {end_node: 0 }
+        @frontier = [ path ]
+      end
+
+      def run
+
+        while @frontier.length > 0 
+          path = remove_choice
+          return path if path.end_node == @end_node
+          edges = @graph.find_edges( path.end_node)
+          puts "no edges found for #{path.end_node.name} #{@graph.edges.length}" unless edges.length > 0
+          edges.each do |edge|
+            begin
+              end_node = edge.start_node == path.end_node ? edge.end_node : edge.start_node
+              new_edge = Edge.new( start_node: path.end_node, end_node: end_node, directed: true, cost: edge.cost )
+              puts( "n:#{ new_edge.to_s } e:#{edge} n:#{end_node} s:#{path.end_node} #{edge.start_node == new_edge.end_node } #{edge.end_node}")
+              new_path = Path.new(edges:path.edges).add_edge( new_edge )
+              if  @explored[new_path.end_node].nil? ||  measure( path  ) < @explored[new_path.end_node]
+                @frontier << new_path
+                @explored[ new_path.end_node ] = measure( new_path )
+              end
+            rescue Errors::CircularPath
+              puts "circular #{ new_path.to_s }"
+              # no need to check this path
+            end
+          end
+        end
+        raise Errors::FrontierEmpty 
+      end
+
+      def remove_choice
+        @frontier.sort! do |path1,path2|
+          measure( path2 ) <=> measure( path1 ) # reverse 
+        end
+        puts "frontier: #{@frontier.length}"
+        @frontier.pop # pops shortest
+      end
+
+      # the standard approach is breath first
+      def measure( path )
+        path.length
+      end 
+      
+    end 
+  end
+end

data/lib/newral/networks/backpropagation_network.rb

@@ -0,0 +1,68 @@
+module Newral
+  module Networks
+    module Errors
+      class Errors::OnlyPossibleForHidden < StandardError ; end 
+    end 
+
+    class BackpropagationNetwork < Network
+      def initialize( number_of_inputs:2, number_of_hidden:2, number_of_outputs:2 )
+        super()
+        add_layer "hidden" do 
+          number_of_hidden.times do |idx|
+            add_neuron "hidden_#{idx}", weight_length:number_of_inputs
+          end 
+        end
+      
+        
+        add_layer "output" do 
+          number_of_outputs.times do |idx|
+            add_neuron "output_#{idx}", weight_length:number_of_hidden
+          end 
+        end
+        
+        # in this network all hidden neurons link to all output neurons
+        @layers["hidden"].neurons.each do |hidden_neuron|
+          @layers["output"].neurons.each  do |output_neuron|
+            output_neuron.add_input hidden_neuron
+          end 
+        end
+      end
+  
+
+      
+      # gets an array of inputs and the corresponding expected outputs
+      # first we update our output layer then our hidden layer
+      def train( input: [], output: [] )
+        before_error =  calculate_error( input: input,output: output )
+        input.each_with_index do |input,idx| 
+          calculated_output = update_with_vector( input )
+          @layers["output"].neurons.each_with_index do |neuron,neuron_idx|
+            neuron.adjust_weights( expected: output[ idx ][ neuron_idx ])
+          end 
+
+          @layers["hidden"].neurons.each do |neuron|
+            neuron.adjust_weights( expected: output[ idx ], layer: :hidden, output: calculated_output, weights_at_output_nodes: output_weights( neuron ))
+          end 
+        end
+        new_error =  calculate_error( input: input,output: output )
+        before_error-new_error
+      end 
+
+      # gets the weights of the output neurons this input feeds to 
+      # this of course can be done much simpler (as its always the nth weight of the output neuron)
+      # however we want to stay explicit 
+      def output_weights( neuron )
+        raise Errors::OnlyPossibleForHidden unless @layers["hidden"].neurons.member?( neuron )
+        weights = []
+        @layers["output"].neurons.each do |output_neuron|
+          output_neuron.inputs.each_with_index do |input,idx| 
+            weights << output_neuron.weights[ idx ] if input == neuron
+          end 
+        end 
+       weights 
+      end 
+      
+    end 
+  
+  end
+end 

data/lib/newral/networks/layer.rb

@@ -0,0 +1,28 @@
+module Newral
+  module Networks
+    class Layer
+      attr_reader  :neurons, :identifier
+
+      def initialize( identifier: nil )
+          @identifier = identifier
+          @neurons = []
+      end 
+      
+      def add_neuron( neuron )
+        @neurons << neuron 
+      end
+
+      def weights 
+        @neurons.collect(&:weights).flatten
+      end 
+
+      def biases 
+        neurons.collect(&:bias)
+      end
+
+      def outputs
+        neurons.collect(&:output)
+      end
+    end 
+  end 
+end 

data/lib/newral/networks/network.rb

@@ -0,0 +1,146 @@
+module Newral
+  module Networks
+    module Errors 
+      class InvalidType < StandardError; end 
+      class IdentifierExists < StandardError; end 
+      class NotImplemented < StandardError; end 
+    end 
+
+    class Network
+      attr_reader :output, :neurons, :layers
+
+      def initialize
+        @layers = {}
+        @neurons = {}
+        @layer_identifier = "input"
+      end 
+
+      def self.define( &block )
+        layout = self.new 
+        layout.instance_eval( &block )
+        layout
+      end 
+
+      def add_layer( identifier, &block )
+        @layer_identifier = identifier
+        @layers[ identifier ] = Layer.new( identifier: identifier )
+        self.instance_eval &block if block_given?
+      end
+      
+      def add_neuron( identifier, neuron: nil, weights: nil, bias: nil, weight_length: nil, type: 'sigmoid' )
+        raise Errors::IdentifierExists if @neurons[ identifier ] && (  neuron || weights || bias )
+        unless neuron 
+          neuron = case type.to_s 
+            when 'perceptron' then Perceptron.new( weights: weights, bias: bias, weight_length: weight_length  )
+            when 'sigmoid' then Sigmoid.new( weights: weights, bias: bias , weight_length: weight_length )
+          else 
+            raise Errors::InvalidType
+          end 
+        end 
+            
+        @neurons[ identifier ] = neuron
+        @layers[ @layer_identifier ].add_neuron( neuron )
+      end 
+
+      # specify the identifiers of the two neurons to connect
+      def connect( from: nil, to: nil )
+        input_neuron = @neurons[ to ]
+        output_neuron  = @neurons[ from ]
+        input_neuron.add_input( output_neuron  )
+      end
+
+      def update_first_layer_with_vector( input )
+        layer = @layers.first
+        @output = layer[1].neurons.collect do |n|
+          n.update_with_vector input
+        end
+        @output 
+      end 
+      
+      def update_neuron( identifier, input  )
+        @neurons[ identifier ].update_with_vector( input )
+      end 
+
+      def update_layers( start:0 )
+        @layers.to_a[start..@layers.size].each do |layer |
+          @output = layer[1].neurons.collect do |n|
+              n.output
+          end 
+        end
+      end 
+
+      def update_with_vector( input )
+        update_first_layer_with_vector( input )
+        update_layers( start: 1)
+        @output 
+      end
+
+      # use this for simple networks were neurons are set by hand
+      def update( &block )
+        self.instance_eval( &block ) if block_given?  
+        update_layers
+        @output
+      end
+      
+      def output_of_neuron( identifier )
+        @neurons[ identifier ].output
+      end
+
+      def train( inputs: [], output: [] )
+        raise Errors::NotImplemented, "Use Subclass Backpropagation Training"
+      end
+
+      def set_weights_and_bias( layer: 'hidden', weights: [], bias: [])
+        @layers[layer].neurons.each_with_index do |neuron,idx|
+          neuron.set_weights_and_bias( weights: weights[ idx ], bias: bias[idx])
+        end 
+      end
+
+      # by implementing these functions we can use a network for all 
+      # training algorithms (although this is really just a proove of concept as using Greedy for Neural Networks does not lead to great results)
+
+      def calculate( input )
+        update_with_vector( input )
+      end
+
+      def calculate_error( input: [],output: [] )
+        expected_values = [] # output can be longer than input
+        calculated_values = []
+        input.each_with_index do |x,idx|
+          calculated_values << calculate( x )
+          expected_values << output[idx] 
+        end 
+        Newral::ErrorCalculation.mean_square( calculated_values, expected_values  )/2
+      end
+
+      def number_of_directions
+        @neurons.sum{ |n| n[1].number_of_directions }
+      end
+
+      def move( direction: 0, step:0.01, step_percentage: nil )
+        raise Errors::InvalidDirection if direction >= number_of_directions
+        new_network = Marshal.load(Marshal.dump(self))
+        idx = 0
+        new_network.neurons.each do |key,neuron|
+          if idx+neuron.number_of_directions-1 >= direction # 
+            meuron = neuron.dup.move( direction: direction-idx, step: step, step_percentage: step_percentage)
+            return new_network 
+          end 
+          idx = idx+neuron.number_of_directions
+        end
+        new_network
+      end 
+
+      def move_random( low_range: -0.9, high_range: 0.9 ) 
+        number_of_directions.times do |direction|
+          step = low_range+rand()*(high_range.to_f-low_range.to_f) 
+          move( direction: direction, step: step )
+        end
+        self
+      end
+          
+
+
+    end 
+  end 
+end