ai4r 1.13 → 2.0

data/lib/ai4r/genetic_algorithm/genetic_algorithm.rb

@@ -1,26 +1,24 @@
+# frozen_string_literal: true
+
 # Author::    Sergio Fierens
 # License::   MPL 1.1
 # Project::   ai4r
-# Url::       http://ai4r.org/
+# Url::       https://github.com/SergioFierens/ai4r
 #
-# You can redistribute it and/or modify it under the terms of 
-# the Mozilla Public License version 1.1  as published by the 
+# You can redistribute it and/or modify it under the terms of
+# the Mozilla Public License version 1.1  as published by the
 # Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+require_relative 'chromosome_base'
+require_relative 'tsp_chromosome'
+
 module Ai4r
-  
-  # The GeneticAlgorithm module implements the GeneticSearch and Chromosome 
-  # classes. The GeneticSearch is a generic class, and can be used to solved 
-  # any kind of problems. The GeneticSearch class performs a stochastic search 
-  # of the solution of a given problem.
-  # 
-  # The Chromosome is "problem specific". Ai4r built-in Chromosome class was 
-  # designed to model the Travelling salesman problem. If you want to solve other 
-  # type of problem, you will have to modify the Chromosome class, by overwriting 
-  # its fitness, reproduce, and mutate functions, to model your specific problem.
+  # The GeneticAlgorithm module implements the GeneticSearch class. The
+  # GeneticSearch is a generic class, and can be used to solve any kind of
+  # problem. The Chromosome implementation is problem specific and must conform
+  # to +ChromosomeBase+.
   module GeneticAlgorithm
-
     #   This class is used to automatically:
-    #   
+    #
     #     1. Choose initial population
     #     2. Evaluate the fitness of each individual in the population
     #     3. Repeat
@@ -34,14 +32,23 @@ module Ai4r
     #     - Chromosome
     #     - Population
     class GeneticSearch
-
-      attr_accessor :population
-
-
-      def initialize(initial_population_size, generations)
+      attr_accessor :population, :mutation_rate, :crossover_rate, :fitness_threshold,
+                    :max_stagnation, :on_generation
+      attr_reader :chromosome_class
+
+      # @return [Object]
+      def initialize(initial_population_size, generations, chromosome_class = TspChromosome,
+                     mutation_rate = 0.3, crossover_rate = 0.4,
+                     fitness_threshold = nil, max_stagnation = nil, on_generation = nil)
         @population_size = initial_population_size
         @max_generation = generations
         @generation = 0
+        @chromosome_class = chromosome_class
+        @mutation_rate = mutation_rate
+        @crossover_rate = crossover_rate
+        @fitness_threshold = fitness_threshold
+        @max_stagnation = max_stagnation
+        @on_generation = on_generation
       end
 
       #     1. Choose initial population
@@ -51,97 +58,127 @@ module Ai4r
       #           2. Breed new generation through crossover and mutation (genetic operations) and give birth to offspring
       #           3. Evaluate the individual fitnesses of the offspring
       #           4. Replace worst ranked part of population with offspring
-      #     4. Until termination    
+      #     4. Until termination
       #     5. Return the best chromosome
+      # @return [Object]
       def run
-        generate_initial_population                    #Generate initial population 
+        generate_initial_population                    # Generate initial population
+        best = best_chromosome
+        best_fitness = best.fitness
+        stagnation = 0
+        @on_generation&.call(@generation, best_fitness)
         @max_generation.times do
-          selected_to_breed = selection                #Evaluates current population 
-          offsprings = reproduction selected_to_breed  #Generate the population for this new generation
+          @generation += 1
+          selected_to_breed = selection                # Evaluates current population
+          offsprings = reproduction selected_to_breed  # Generate the population for this new generation
           replace_worst_ranked offsprings
+          current_best = best_chromosome
+          if current_best.fitness > best_fitness
+            best_fitness = current_best.fitness
+            best = current_best
+            stagnation = 0
+          else
+            stagnation += 1
+          end
+          @on_generation&.call(@generation, best_fitness)
+          break if (@fitness_threshold && best_fitness >= @fitness_threshold) ||
+                   (@max_stagnation && stagnation >= @max_stagnation)
         end
-        return best_chromosome
+        best
       end
 
-
+      # @return [Object]
       def generate_initial_population
-       @population = []
-       @population_size.times do
-         population << Chromosome.seed
-       end
+        @population = []
+        @population_size.times do
+          population << @chromosome_class.seed
+        end
       end
 
       # Select best-ranking individuals to reproduce
-      # 
-      # Selection is the stage of a genetic algorithm in which individual 
-      # genomes are chosen from a population for later breeding. 
-      # There are several generic selection algorithms, such as 
+      #
+      # Selection is the stage of a genetic algorithm in which individual
+      # genomes are chosen from a population for later breeding.
+      # There are several generic selection algorithms, such as
       # tournament selection and roulette wheel selection. We implemented the
       # latest.
-      # 
+      #
       # Steps:
-      # 
+      #
       # 1. The fitness function is evaluated for each individual, providing fitness values
       # 2. The population is sorted by descending fitness values.
       # 3. The fitness values ar then normalized. (Highest fitness gets 1, lowest fitness gets 0). The normalized value is stored in the "normalized_fitness" attribute of the chromosomes.
       # 4. A random number R is chosen. R is between 0 and the accumulated normalized value (all the normalized fitness values added togheter).
       # 5. The selected individual is the first one whose accumulated normalized value (its is normalized value plus the normalized values of the chromosomes prior it) greater than R.
-      # 6. We repeat steps 4 and 5, 2/3 times the population size.    
+      # 6. We repeat steps 4 and 5, 2/3 times the population size.
+      # @return [Object]
       def selection
-        @population.sort! { |a, b| b.fitness <=> a.fitness}
+        @population.sort! { |a, b| b.fitness <=> a.fitness }
         best_fitness = @population[0].fitness
         worst_fitness = @population.last.fitness
         acum_fitness = 0
-        if best_fitness-worst_fitness > 0
-        @population.each do |chromosome| 
-          chromosome.normalized_fitness = (chromosome.fitness - worst_fitness)/(best_fitness-worst_fitness)
-          acum_fitness += chromosome.normalized_fitness
-        end
+        if (best_fitness - worst_fitness).positive?
+          @population.each do |chromosome|
+            chromosome.normalized_fitness = (chromosome.fitness - worst_fitness) / (best_fitness - worst_fitness)
+            acum_fitness += chromosome.normalized_fitness
+          end
         else
-          @population.each { |chromosome| chromosome.normalized_fitness = 1}  
+          @population.each { |chromosome| chromosome.normalized_fitness = 1 }
         end
         selected_to_breed = []
-        ((2*@population_size)/3).times do 
+        ((2 * @population_size) / 3).times do
           selected_to_breed << select_random_individual(acum_fitness)
         end
         selected_to_breed
       end
 
-      # We combine each pair of selected chromosome using the method 
+      # We combine each pair of selected chromosome using the method
       # Chromosome.reproduce
       #
-      # The reproduction will also call the Chromosome.mutate method with 
+      # The reproduction will also call the Chromosome.mutate method with
       # each member of the population. You should implement Chromosome.mutate
       # to only change (mutate) randomly. E.g. You could effectivly change the
-      # chromosome only if 
+      # chromosome only if
       #     rand < ((1 - chromosome.normalized_fitness) * 0.4)
+      # @param selected_to_breed [Object]
+      # @return [Object]
       def reproduction(selected_to_breed)
         offsprings = []
-        0.upto(selected_to_breed.length/2-1) do |i|
-          offsprings << Chromosome.reproduce(selected_to_breed[2*i], selected_to_breed[2*i+1])
+        0.upto((selected_to_breed.length / 2) - 1) do |i|
+          offsprings << @chromosome_class.reproduce(
+            selected_to_breed[2 * i],
+            selected_to_breed[(2 * i) + 1],
+            @crossover_rate
+          )
         end
         @population.each do |individual|
-          Chromosome.mutate(individual)
+          @chromosome_class.mutate(individual, @mutation_rate)
         end
-        return offsprings
+        offsprings
       end
 
       # Replace worst ranked part of population with offspring
+      # @param offsprings [Object]
+      # @return [Object]
       def replace_worst_ranked(offsprings)
         size = offsprings.length
-        @population = @population [0..((-1*size)-1)] + offsprings
+        @population = @population[0..(-size - 1)] + offsprings
       end
 
       # Select the best chromosome in the population
+      # @return [Object]
       def best_chromosome
         the_best = @population[0]
         @population.each do |chromosome|
           the_best = chromosome if chromosome.fitness > the_best.fitness
         end
-        return the_best
+        the_best
       end
 
-      private 
+      private
+
+      # @param acum_fitness [Object]
+      # @return [Object]
       def select_random_individual(acum_fitness)
         select_random_target = acum_fitness * rand
         local_acum = 0
@@ -150,121 +187,6 @@ module Ai4r
           return chromosome if local_acum >= select_random_target
         end
       end
-
-    end
-
-    # A Chromosome is a representation of an individual solution for a specific 
-    # problem. You will have to redifine the Chromosome representation for each
-    # particular problem, along with its fitness, mutate, reproduce, and seed 
-    # methods.
-    class Chromosome
-
-      attr_accessor :data
-      attr_accessor :normalized_fitness
-
-      def initialize(data)
-        @data = data
-      end
-
-      # The fitness method quantifies the optimality of a solution 
-      # (that is, a chromosome) in a genetic algorithm so that that particular 
-      # chromosome may be ranked against all the other chromosomes. 
-      # 
-      # Optimal chromosomes, or at least chromosomes which are more optimal, 
-      # are allowed to breed and mix their datasets by any of several techniques, 
-      # producing a new generation that will (hopefully) be even better.
-      def fitness
-        return @fitness if @fitness
-        last_token = @data[0]
-        cost = 0
-        @data[1..-1].each do |token|
-          cost += @@costs[last_token][token]
-          last_token = token
-        end
-        @fitness = -1 * cost
-        return @fitness
-      end
-
-      # mutation method is used to maintain genetic diversity from one 
-      # generation of a population of chromosomes to the next. It is analogous 
-      # to biological mutation. 
-      # 
-      # The purpose of mutation in GAs is to allow the 
-      # algorithm to avoid local minima by preventing the population of 
-      # chromosomes from becoming too similar to each other, thus slowing or even 
-      # stopping evolution.
-      # 
-      # Calling the mutate function will "probably" slightly change a chromosome
-      # randomly. 
-      #
-      # This implementation of "mutation" will (probably) reverse the 
-      # order of 2 consecutive randome nodes 
-      # (e.g. from [ 0, 1, 2, 4] to [0, 2, 1, 4]) if:
-      #     ((1 - chromosome.normalized_fitness) * 0.4)
-      def self.mutate(chromosome)
-        if chromosome.normalized_fitness && rand < ((1 - chromosome.normalized_fitness) * 0.3)
-          data = chromosome.data
-          index = rand(data.length-1)
-          data[index], data[index+1] = data[index+1], data[index]
-          chromosome.data = data
-          @fitness = nil
-        end
-      end
-
-      # Reproduction method is used to combine two chromosomes (solutions) into 
-      # a single new chromosome. There are several ways to
-      # combine two chromosomes: One-point crossover, Two-point crossover,
-      # "Cut and splice", edge recombination, and more. 
-      # 
-      # The method is usually dependant of the problem domain.
-      # In this case, we have implemented edge recombination, wich is the 
-      # most used reproduction algorithm for the Travelling salesman problem.
-      def self.reproduce(a, b)
-        data_size = @@costs[0].length
-        available = []
-        0.upto(data_size-1) { |n| available << n }
-        token = a.data[0]
-        spawn = [token]
-        available.delete(token)
-        while available.length > 0 do 
-          #Select next
-          if token != b.data.last && available.include?(b.data[b.data.index(token)+1])
-            next_token = b.data[b.data.index(token)+1]
-          elsif token != a.data.last && available.include?(a.data[a.data.index(token)+1])
-            next_token = a.data[a.data.index(token)+1] 
-          else
-            next_token = available[rand(available.length)]
-          end
-          #Add to spawn
-          token = next_token
-          available.delete(token)
-          spawn << next_token
-          a, b = b, a if rand < 0.4
-        end
-        return Chromosome.new(spawn)
-      end
-
-      # Initializes an individual solution (chromosome) for the initial 
-      # population. Usually the chromosome is generated randomly, but you can 
-      # use some problem domain knowledge, to generate a 
-      # (probably) better initial solution.
-      def self.seed
-        data_size = @@costs[0].length
-        available = []
-        0.upto(data_size-1) { |n| available << n }
-        seed = []
-        while available.length > 0 do 
-          index = rand(available.length)
-          seed << available.delete_at(index)
-        end
-        return Chromosome.new(seed)
-      end
-
-      def self.set_cost_matrix(costs)
-        @@costs = costs
-      end
     end
-
   end
-
 end

data/lib/ai4r/genetic_algorithm/tsp_chromosome.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'chromosome_base'
+
+module Ai4r
+  module GeneticAlgorithm
+    # Chromosome implementation for the Travelling Salesman Problem.
+    class TspChromosome < ChromosomeBase
+      # @return [Object]
+      def fitness
+        return @fitness if @fitness
+
+        last_token = @data[0]
+        cost = 0
+        @data[1..].each do |token|
+          cost += @@costs[last_token][token]
+          last_token = token
+        end
+        @fitness = -1 * cost
+        @fitness
+      end
+
+      # @param chromosome [Object]
+      # @param mutation_rate [Object]
+      # @return [Object]
+      def self.mutate(chromosome, mutation_rate = 0.3)
+        return unless chromosome.normalized_fitness && rand < ((1 - chromosome.normalized_fitness) * mutation_rate)
+
+        data = chromosome.data
+        # Swapping the first two cities can sometimes keep the fitness
+        # unchanged depending on the cost matrix. Pick an inner segment
+        # instead to ensure the route actually changes.
+        index = (1...(data.length - 1)).to_a.sample
+        data[index], data[index + 1] = data[index + 1], data[index]
+        chromosome.data = data
+        chromosome.instance_variable_set(:@fitness, nil)
+      end
+
+      # @param a [Object]
+      # @param b [Object]
+      # @param crossover_rate [Object]
+      # @return [Object]
+      def self.reproduce(a, b, crossover_rate = 0.4)
+        data_size = @@costs[0].length
+        available = []
+        0.upto(data_size - 1) { |n| available << n }
+        token = a.data[0]
+        spawn = [token]
+        available.delete(token)
+        while available.length.positive?
+          next_token = if token != b.data.last && available.include?(b.data[b.data.index(token) + 1])
+                         b.data[b.data.index(token) + 1]
+                       elsif token != a.data.last && available.include?(a.data[a.data.index(token) + 1])
+                         a.data[a.data.index(token) + 1]
+                       else
+                         available.sample
+                       end
+          token = next_token
+          available.delete(token)
+          spawn << next_token
+          a, b = b, a if rand < crossover_rate
+        end
+        new(spawn)
+      end
+
+      # @return [Object]
+      def self.seed
+        data_size = @@costs[0].length
+        available = []
+        0.upto(data_size - 1) { |n| available << n }
+        seed = []
+        seed << available.delete(available.sample) while available.length.positive?
+        new(seed)
+      end
+
+      # @param costs [Object]
+      # @return [Object]
+      def self.set_cost_matrix(costs)
+        @@costs = costs
+      end
+    end
+  end
+end

data/lib/ai4r/hmm/hidden_markov_model.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+# Author::    OpenAI Codex
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       https://github.com/SergioFierens/ai4r
+#
+# You can redistribute it and/or modify it under the terms of
+# the Mozilla Public License version 1.1  as published by the
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+require_relative '../data/parameterizable'
+
+module Ai4r
+  module Hmm
+    # = Introduction
+    #
+    # A simple implementation of a discrete Hidden Markov Model (HMM).
+    # You must provide the states and observations as well as the
+    # probability matrices. This class exposes two main operations:
+    #
+    # * +eval(sequence)+: probability of the observation sequence.
+    # * +decode(sequence)+: most likely hidden state sequence (Viterbi).
+    #
+    # Probabilities are provided as arrays. Example:
+    #
+    #   states = [:Rainy, :Sunny]
+    #   observations = [:walk, :shop, :clean]
+    #   start_prob = [0.6, 0.4]
+    #   transition = [[0.7, 0.3], [0.4, 0.6]]
+    #   emission = [[0.1, 0.4, 0.5], [0.6, 0.3, 0.1]]
+    #   hmm = Ai4r::Hmm::HiddenMarkovModel.new(
+    #     states: states,
+    #     observations: observations,
+    #     start_prob: start_prob,
+    #     transition_prob: transition,
+    #     emission_prob: emission
+    #   )
+    #   hmm.eval([:walk, :shop, :clean])
+    #   hmm.decode([:walk, :shop, :clean])
+    class HiddenMarkovModel
+      include Ai4r::Data::Parameterizable
+
+      parameters_info states: 'Array of hidden states',
+                      observations: 'Array of observation symbols',
+                      start_prob: 'Initial state probabilities',
+                      transition_prob: 'State transition probability matrix',
+                      emission_prob: 'Observation probability matrix'
+
+      def initialize(params = {})
+        @states = []
+        @observations = []
+        @start_prob = []
+        @transition_prob = []
+        @emission_prob = []
+        set_parameters(params) if params && !params.empty?
+      end
+
+      # Probability of the given observation sequence using the
+      # forward algorithm.
+      def eval(sequence)
+        forward(sequence).last.sum
+      end
+
+      # Return the most likely hidden state sequence for the given
+      # observations using the Viterbi algorithm.
+      def decode(sequence)
+        viterbi(sequence)
+      end
+
+      protected
+
+      def forward(sequence)
+        probs = []
+        sequence.each_with_index do |obs, t|
+          probs[t] = []
+          obs_index = @observations.index(obs)
+          if t.zero?
+            @states.each_index do |i|
+              probs[t][i] = @start_prob[i] * @emission_prob[i][obs_index]
+            end
+          else
+            @states.each_index do |j|
+              sum = 0.0
+              @states.each_index do |i|
+                sum += probs[t - 1][i] * @transition_prob[i][j]
+              end
+              probs[t][j] = sum * @emission_prob[j][obs_index]
+            end
+          end
+        end
+        probs
+      end
+
+      def viterbi(sequence)
+        v = []
+        bptr = []
+        sequence.each_with_index do |obs, t|
+          obs_index = @observations.index(obs)
+          v[t] = []
+          bptr[t] = []
+          if t.zero?
+            @states.each_index do |i|
+              v[t][i] = @start_prob[i] * @emission_prob[i][obs_index]
+              bptr[t][i] = 0
+            end
+          else
+            @states.each_index do |j|
+              max_prob = -Float::INFINITY
+              max_state = 0
+              @states.each_index do |i|
+                prob = v[t - 1][i] * @transition_prob[i][j]
+                if prob > max_prob
+                  max_prob = prob
+                  max_state = i
+                end
+              end
+              v[t][j] = max_prob * @emission_prob[j][obs_index]
+              bptr[t][j] = max_state
+            end
+          end
+        end
+        path = Array.new(sequence.length)
+        last_state = v.last.each_with_index.max[1]
+        path[-1] = @states[last_state]
+        (sequence.length - 1).downto(1) do |t|
+          last_state = bptr[t][last_state]
+          path[t - 1] = @states[last_state]
+        end
+        path
+      end
+    end
+  end
+end

data/lib/ai4r/neural_network/activation_functions.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Author::    Sergio Fierens
+# License::   MPL 1.1
+# Project::   ai4r
+# Url::       https://github.com/SergioFierens/ai4r
+#
+# You can redistribute it and/or modify it under the terms of
+# the Mozilla Public License version 1.1  as published by the
+# Mozilla Foundation at http://www.mozilla.org/MPL/MPL-1.1.txt
+
+module Ai4r
+  module NeuralNetwork
+    # Collection of common activation functions and their derivatives.
+    module ActivationFunctions
+      FUNCTIONS = {
+        sigmoid: ->(x) { 1.0 / (1.0 + Math.exp(-x)) },
+        tanh: ->(x) { Math.tanh(x) },
+        relu: ->(x) { [x, 0].max },
+
+        softmax: lambda do |arr|
+          max = arr.max
+          exps = arr.map { |v| Math.exp(v - max) }
+          sum = exps.inject(:+)
+          exps.map { |e| e / sum }
+        end
+      }.freeze
+
+      DERIVATIVES = {
+        sigmoid: ->(y) { y * (1 - y) },
+        tanh: ->(y) { 1.0 - (y**2) },
+        relu: ->(y) { y.positive? ? 1.0 : 0.0 },
+        softmax: ->(y) { y * (1 - y) }
+      }.freeze
+    end
+  end
+end