newral 0.1

data/lib/newral/networks/perceptron.rb

@@ -0,0 +1,84 @@
+# http://neuralnetworksanddeeplearning.com/chap1.html
+module Newral
+  module Networks
+    module Errors
+      class InputAndWeightSizeDiffer < StandardError; end 
+      class WeightsAndWeightLengthGiven < StandardError; end 
+    end
+
+    class Perceptron
+      attr_reader :weights,:bias, :last_output, :inputs
+      # to create random weights just specify weight_length
+      def initialize(weights:[],bias:0, weight_length: nil, max_random_weight:1, min_random_weight:-1 )
+        raise Errors::WeightsAndWeightLengthGiven if weight_length && ( weights || ( weights && weights.size > 0 ))
+        @max_random_weight = max_random_weight
+        @min_random_weight=  min_random_weight
+        @weights =weights || []
+        @weights = weight_length.times.collect{ |i| (max_random_weight-min_random_weight)*rand()+min_random_weight } if weight_length
+        @bias = bias || (weight_length && (max_random_weight-min_random_weight)*rand()+min_random_weight ) || 0
+        @inputs = []
+        @last_output = nil
+      end 
+
+      def set_weights_and_bias( weights:[], bias: nil )
+        @weights = weights
+        @bias = bias || 0 # if none specified
+      end 
+
+      def calculate_value 
+        raise Errors::InputAndWeightSizeDiffer, "weights: #{@weights.size  }, #{ @inputs.size }" unless @weights.size == @inputs.size
+        value = 0
+        @inputs.each_with_index do |input,idx|
+          val = calculate_input( input )
+          value = value+val*@weights[idx]
+        end
+        value = value+@bias 
+      end 
+
+      def calculate_input( input )
+        input.kind_of?( Perceptron ) ? input.last_output : input
+      end
+
+      def output
+        @last_output = calculate_value <= 0 ? 0 : 1
+      end
+
+      def update_with_vector( inputs )
+        @inputs = inputs
+        output
+      end
+
+      def add_input( object )
+        if object.kind_of?( Array ) 
+           @inputs=object
+        else 
+          @inputs << object
+        end
+        # automatically add a weight if number of inputs exceeds weight size 
+        weights << (@max_random_weight-@min_random_weight)*rand()+@min_random_weight if weights.length < @inputs.length
+      end
+
+      # move + number of directions are just needed for some training algorithms 
+      # not typically used for neural networks (like greedy)
+      # mainly implemented here for a proove of concept
+      def number_of_directions
+        @weights.size+1
+      end
+ 
+
+       def move( direction: 0, step:0.01, step_percentage: nil )
+        raise Errors::InvalidDirection if direction >= number_of_directions
+        if direction < @weights.size 
+          @weights[direction] = step_percentage ?  @weights[direction]*(1+step_percentage.to_f/100) : @weights[direction]+step
+        else
+          @bias = step_percentage ?  @bias*(1+step_percentage.to_f/100) : @bias+step
+        end
+        self
+      end 
+      
+
+    end
+
+  end
+end
+

data/lib/newral/networks/sigmoid.rb

@@ -0,0 +1,55 @@
+module Newral
+  module Networks
+    class Sigmoid < Perceptron
+
+      def output
+        value = calculate_value
+        @last_output =  1/(1+Math.exp(value*-1))
+      end 
+
+      # if you want to know how this works
+      # visit https://mattmazur.com/2015/03/17/a-step-by-step-backpropagation-example/
+      def delta_rule( expected: nil )
+        error_delta = []
+        @weights.each_with_index do |weight,idx|
+          input = calculate_input(  @inputs[ idx ] )
+          error_delta << -(expected-output)*(output)*(1-output )*input
+        end
+        error_delta
+      end
+      
+
+      # this just works for 1 hidden layer 
+      # https://stats.stackexchange.com/questions/70168/back-propagation-in-neural-nets-with-2-hidden-layers
+      # bias also not adjusted as biases are seen as constants
+      def delta_rule_hidden( output: nil, expected: nil, weights_at_output_nodes: nil )
+        error_delta = []
+        @inputs.each do |input|
+          d_e_total_d_out = 0
+          output.each_with_index do |result,idx|
+            d_e_total_d_out_idx = -( expected[idx]-result )
+            d_e_out_d_net = (1-result)*result
+            d_e_total_d_out_idx = d_e_total_d_out_idx*d_e_out_d_net*weights_at_output_nodes[idx]
+            d_e_total_d_out = d_e_total_d_out+d_e_total_d_out_idx
+          end
+          d_out_d_net = (1-@last_output)*@last_output
+          error_delta << d_e_total_d_out*d_out_d_net*calculate_input( input )
+        end
+        error_delta
+      end 
+
+      # depending on where the neuron is placed we need other infos to adjust the weights 
+      # on output we just need the expected results
+      # for hidden neurons we also need to know the weights at the output nodes 
+      # and the actual output of the network
+      def adjust_weights( expected: nil, learning_rate:0.5, layer: :output, weights_at_output_nodes: nil, output: nil )
+        error_delta = layer.to_sym == :output ?  delta_rule( expected: expected ) : delta_rule_hidden( output: output, expected: expected, weights_at_output_nodes: weights_at_output_nodes )
+        @weights.each_with_index do |weight,idx|
+          @weights[idx] = @weights[idx]-error_delta[ idx ]*learning_rate
+        end 
+      end 
+
+    end
+  end
+
+end

data/lib/newral/probability.rb

@@ -0,0 +1,42 @@
+module Newral
+
+  class Probability 
+    attr_reader :key, :probability, :apriori
+    def initialize( key, probability, apriori:nil )
+      @key = key 
+      @probability = probability
+      @apriori = apriori
+      @key = "#{key}|#{apriori}" if apriori
+    end
+
+    def *( other_probability )
+      Probability.new("#{self.key}*#{other_probability.key}",self.probability*other_probability.probability)
+    end
+
+    def /( other_probability )
+      Probability.new("#{self.key}/#{other_probability.key}",self.probability/other_probability.probability)
+    end
+
+    def !
+      Probability.new("!#{key}",1-probability)
+    end 
+
+    def+(other_probability)
+      Probability.new("#{self.key}+#{other_probability.key}",self.probability+other_probability.probability)
+    end
+
+    def apriori=( apriori: other_probability, probability: nil )
+       Probability.new("#{self.key}|#{other_probability.key}",probability)
+    end
+
+    def and( other_probability )
+      Probability.new("#{self.key}^#{other_probability.key}",self.probability*other_probability.probability)
+    end
+
+    def or( other_probability )
+      Probability.new("#{self.key}*#{other_probability.key}",self.probability*other_probability.probability)
+    end
+
+  end 
+
+end

data/lib/newral/probability_set.rb

@@ -0,0 +1,108 @@
+module Newral
+
+  class ProbabilitySet
+    attr_reader :history
+    def initialize(  )
+      @probabilities={}
+      @history = []
+    end
+
+    def []( key )
+      @probabilities[ key ] || ( @probabilities[key] = compute(key))
+    end
+
+    def set( key, set_value )
+      @probabilities[ key ] = set_value
+    end
+
+    def multiply( key,other_key, set_value: nil )
+      computed_key_name = "#{key}*#{other_key}"
+      return @probabilities[computed_key_name] if @probabilities[ computed_key_name ] &&set_value.nil?
+      set_value ||= compute( key )*compute( other_key )
+      set( computed_key_name, set_value )
+    end
+
+    def divide( key,other_key, set_value: nil )
+      computed_key_name = "#{key}/#{other_key}"
+      return @probabilities[ computed_key_name ] if @probabilities[ computed_key_name] &&set_value.nil?
+      set_value ||= compute( key )*compute( other_key )
+      set( computed_key_name, set_value )
+    end
+
+    def not( key, set_value: nil )
+      computed_key_name = "!#{key}"
+      return @probabilities[ computed_key_name ] if @probabilities[computed_key_name ] &&set_value.nil?
+      set_value ||= 1-compute( key )
+      set( computed_key_name, set_value )
+    end 
+
+    def add( key,other_key, set_value: nil )
+      computed_key_name = "#{key}+#{other_key}"
+      return @probabilities[ computed_key_name] if @probabilities[ computed_key_name ] && set_value.nil?
+      set_value ||= compute( key )+compute( other_key )
+      set( computed_key_name, set_value )
+    end
+    # aposteriori =( Likelihood * Prior )/ marginal likelihood
+    # P(A|B) = P(B|A)*P(A)/P(B)
+    def aposteriori( key,apriori:nil, set_value: nil )
+      computed_key_name = "#{key}|#{apriori}"
+      return @probabilities[ computed_key_name ] if @probabilities[ computed_key_name ] &&set_value.nil?
+      set_value ||= compute("#{apriori}|#{key}")*compute(key)/compute(apriori)
+     set( computed_key_name, set_value )
+    end
+
+
+    def total( key, apriori: nil )
+      aposteriori(key,apriori: apriori)*compute(apriori)+self.aposteriori(key,apriori: "!#{apriori}")*self.not(apriori)
+    end 
+
+
+    def and( key,other_key, set_value: nil )
+      computed_key_name = "#{key}^#{other_key}"
+      return @probabilities[computed_key_name ] if @probabilities[ computed_key_name ] &&set_value.nil?
+      set_value ||= compute("#{key}|#{other_key}")*compute(other_key)
+      set( computed_key_name, set_value )
+    end
+
+    def or(  key,other_key, set_value: nil )
+      computed_key_name = "#{key}.#{other_key}"
+      return @probabilities[ computed_key_name ] if @probabilities[computed_key_name] &&set_value.nil?
+      set_value ||= compute(key)+compute(other_key)-compute("#{key}^#{other_key}")
+      set( computed_key_name, set_value )
+    end
+
+    # P(R|H,S) = P(H|R,S)*P(R|S)/P(H|S)
+    # P(R|H,!S) = P(H|R,!S)*P(R|!S)/P(H|!S)
+    # 0.9*0.01/(0.9*0.01+0.1*0.99)
+    # P(R|H) = P(H|R)*P(R)/P(H) = 0.9*0.01/  =0.097*0.01
+    # P(H) = P  0.5244999999999999
+
+      def compute( key )
+        probability = if @probabilities[key]
+          @probabilities[key]
+        elsif key.start_with?("!") && @probabilities[key.sub("!","")]
+          self.not(key.sub("!",''))
+        elsif key.match('\|')
+          @history << key unless @history.member?( key )
+          key,apriori=key.split("|")
+          self.aposteriori( key, apriori: apriori)
+        elsif key.match('\^')
+          @history << key unless @history.member?( key )
+          key,other_key=key.split("^")
+          self.and(key,other_key)
+        else
+          apriori_key = @probabilities.keys.find{|p| p.split("|")[0]==key && !p.split("|")[1].match('!') }
+          if apriori_key
+            @history << key unless @history.member?( key )
+            apriori_key = apriori_key.split("|")[1]
+            value = self.total(key,apriori: apriori_key)
+            self.set( key, value)
+          else 
+            raise "not found #{key}"
+          end
+        end
+        probability
+      end
+  end 
+
+end

data/lib/newral/q_learning/base.rb

@@ -0,0 +1,90 @@
+module Newral
+  module QLearning
+    class Base
+      attr_accessor  :game
+      # this q_learning algorithm was posted here
+      # https://www.practicalai.io/teaching-ai-play-simple-game-using-q-learning/
+      # however I extended it so it can play more games
+      # also the q_table is implemente as a hash so actions can differ at different positions
+      # this way the algorithm also needs to know less about the game
+      def initialize( id: nil, game: nil, learning_rate: 0.4, discount: 0.9, epsilon: 0.9, sleep_time: 0.001 )
+        game.set_player( self )
+        @id = id 
+        @game = game
+        @learning_rate = learning_rate
+        @discount = discount
+        @epsilon = epsilon
+        @sleep = sleep_time
+        @random = Random.new
+        @q_hash = {}
+      end
+
+      def set_epsilon( epsilon )
+        @epsilon = epsilon
+      end
+
+      def inform_game_ended
+        get_input( move: false )
+      end
+
+
+      def get_input( move: true )
+        # Our new state is equal to the player position
+        @outcome_state = @game.get_position( player: self )
+        
+        # which actions are available to the player at the moment?
+        @actions = @game.get_actions( player: self )
+        
+        # is this the first run
+        initial_run = @q_hash.empty? 
+
+        @q_hash[@outcome_state] = @q_hash[@outcome_state] || {}
+        @actions.each do |action| 
+           @q_hash[@outcome_state][action] = @q_hash[@outcome_state][action] ||  0.1 # @random.rand/10.0
+        end 
+
+        if initial_run 
+          @action_taken = @actions.first
+        elsif @old_state
+          # If this is not the first run
+          # Evaluate what happened on last action and update Q table
+          
+          # Calculate reward
+          reward = 0 # default is 0
+          if @old_score < @game.get_score( player: self )
+            reward =  [@game.get_score( player: self )-@old_score,1].max # reward is at least 1 if our score increased
+          elsif @old_score > @game.get_score( player: self )
+            reward =  [@old_score-@game.get_score( player: self ),-1].min # reward is smaller or equal -1 if our score decreased
+          else 
+            reward = -0.1 # time is money, we punish moves 
+          end
+           @q_hash[@old_state][@action_taken] = @q_hash[@old_state][@action_taken] + @learning_rate * (reward + @discount * (@q_hash[@outcome_state]).values.max.to_f - @q_hash[@old_state][@action_taken])
+        end
+ 
+        # Capture current state and score
+        @old_score = @game.get_score( player: self )
+        @old_state = @game.get_position( player: self ) # we remember this for next run, its current state 
+        @old_actions = @actions
+        if move # in the goal state we just update the q_hash
+          
+          # Chose action based on Q value estimates for state
+          if @random.rand > @epsilon ||  @q_hash[@old_state].nil?
+            # Select random action
+            @action_taken_index = @random.rand(@actions.length).round
+            @action_taken = @actions[@action_taken_index]
+          else
+            # Select based on Q table, remember @old_state is equal to current state at this point
+            @action_taken = @q_hash[@old_state].to_a.sort{ |v1,v2| v2[1]<=>v1[1]}[0][0]
+            raise "impossible action #{ @action_taken } #{@old_state} #{@q_hash[ @old_state ] } #{ @actions } #{@old_actions } " unless @actions.member?( @action_taken)
+          end
+
+          # Take action
+          return @action_taken
+        else 
+          @old_state = nil # we do not have a old state any more as we have reached an end state
+        end 
+      end
+
+    end
+  end 
+end

data/lib/newral/tools.rb

@@ -0,0 +1,135 @@
+module Newral
+  
+  module Tools
+
+    module Errors 
+      class NoElements < StandardError; end
+    end 
+
+    def self.mean( array )
+      array.sum.to_f/array.length
+    end 
+
+    def self.sigma( array )
+      mean = self.mean( array )
+      sigma_square = array.inject(0){ |value,el| value+(el-mean)**2 }
+      (sigma_square/array.length)**0.5
+    end
+
+    def self.normalize( data, high: nil, low:nil,normalized_high:1,normalized_low:-1)
+      unless high && low 
+        data.sort!
+        high ||= [data[data.length-1],data[0].abs].max
+        low  ||= data[0] >= 0 ? data[0] : [high*-1,data[0]].min
+      end 
+      data.collect do |data_point|
+        (data_point-low)/(high-low).to_f*(normalized_high-normalized_low)+normalized_low
+      end
+    end
+
+    def self.denormalize( data, high: nil, low:nil,normalized_high:1,normalized_low:-1)
+      normalize( data, normalized_high: high, normalized_low: low, high: normalized_high, low: normalized_low)
+    end 
+
+    def self.euclidian_distance( v1, v2 )
+      total = 0.0
+      v1.each_with_index do   |value,idx|
+        total=total+(value-v2[idx])**2
+      end
+      total**0.5
+    end
+
+    def self.max_distance( v1, v2 )
+      max = 0.0
+      v1.each_with_index do   |value,idx|
+        dist=(value-v2[idx]).abs
+        max = dist unless max > dist 
+      end
+      max
+    end
+
+    def self.taxi_cab_distance( v1, v2 )
+      total = 0.0
+      v1.each_with_index do   |value,idx|
+        total=total+(value-v2[idx]).abs
+      end
+      total
+    end
+
+    def self.sort_and_slice( distances, number_of_entries:5,element_at_index:1 )
+        distances.sort do |v1,v2|
+          v1[ element_at_index ]<=>v2[ element_at_index ]
+        end[0..number_of_entries-1]
+    end 
+
+    # point is a vector
+    # clusters have a key , values are an array of point
+    # we iterate over all points and return the closest ones 
+    # as an Array of [key,distance,point]
+    # to classify you can then count the nearest neighbours by key or use the weighted k_nearest_neighbour approach
+    def self.k_nearest_neighbour( point, clusters, number_of_neighbours: 5 )
+      distances = []
+      
+      clusters.each do |key,values|
+        values.each do |value|
+          # we optimize here by sorting on insert, or sort and slice after distances
+          # array exceeds number_of_neighbours*5
+          distances = sort_and_slice( distances, number_of_entries: number_of_neighbours ) if distances.length > number_of_neighbours*5
+          distances << [key,euclidian_distance( point, value ),value]
+        end
+      end
+      sort_and_slice( distances, number_of_entries: number_of_neighbours )
+    end
+
+    # input: array of samples which lead to positive result
+    # example movies user likes with 3 properties action, comedy, romance 
+    #  [[1,0,1],[0,0,1]] => user likes action+romance, romance 
+    # output  be [0,-1,1] => action y/n does not matter, comedy no, romance yes
+    def self.more_general_than_or_equal( samples )
+      hypotheses=[-1]*samples.first.length
+      samples.each do |sample|
+        sample.each_with_index do |v,idx|
+          if v == 1
+            hypotheses[idx] = 1 unless hypotheses[idx] == 0
+          else 
+            hypotheses[idx] = 0 if hypotheses[idx] == 1
+          end
+        end
+      end
+      hypotheses
+    end
+
+   # input: array of samples which lead to negative result
+    # example movies user does not likes with 3 properties action, comedy, romance 
+    #  [[1,0,1],[0,0,1]] => user does not like action+romance, romance 
+    # output  be [-1,1,-1] => action no, romance no
+    def self.general_to_specific( samples )
+      hypotheses=[0]*samples.first.length
+      samples.each do |sample|
+        sample.each_with_index do |v,idx|
+          if v == 1
+            hypotheses[idx] = -1 unless hypotheses[idx] == 1
+          else 
+            hypotheses[idx] = 1 if hypotheses[idx] == 0
+          end
+        end
+      end
+      hypotheses
+    end
+
+ 
+
+    # https://youtu.be/_DhelJs0BFc?t=4m10s
+    # http://keisan.casio.com/exec/system/1180573188
+    def self.gaussian_density( x, mu: nil , sigma: nil, elements:nil )
+      raise Errors::NoElements if ( mu.nil?  || sigma.nil? ) && elements.nil?
+      mu = mean(  elements ) unless mu 
+      sigma = sigma(  elements ) unless sigma 
+      (1.0/((2*Math::PI)**0.5*sigma.to_f))*Math.exp((-1.0/2)*((x-mu)**2/sigma.to_f**2 ))
+    end 
+
+
+  end
+
+
+end