Step by Step solution about How to resolve the algorithm Evolutionary algorithm step by step in the Ruby programming language

This Ruby program uses a genetic algorithm to evolve a string into a target string. It simulates the process of natural selection, where individuals with higher fitness are more likely to survive and reproduce.

Variables:

• @target: The target string to evolve towards.
• Charset: A list of characters that can be used in the evolved string.
• COPIES: The number of copies of each parent to create during mutation.

Functions:

• random_char: Randomly selects a character from the Charset.
• fitness: Calculates the fitness of a candidate string. The fitness is based on how close the candidate is to the target string.
• mutation_rate: Calculates the mutation rate for a candidate string. The mutation rate is higher for strings with lower fitness.
• mutate: Mutates a parent string by randomly changing some of its characters.
• log: Logs the progress of the genetic algorithm, including the iteration number, mutation rate, fitness, and the current candidate string.

Algorithm:

1. Initialize a random parent string.
2. Calculate the fitness of the parent string.
3. Calculate the mutation rate for the parent string.
4. Create COPIES copies of the parent string and mutate each copy.
5. Select the copy with the highest fitness as the new parent string.
6. Repeat steps 2-5 until the parent string matches the target string.

Output:

The program logs the progress of the genetic algorithm, showing the following information for each iteration:

• Iteration number
• Mutation rate
• Fitness of the current parent string
• The current parent string

Once the parent string matches the target string, the program logs the final iteration number, mutation rate, fitness, and the evolved string.

@target = "METHINKS IT IS LIKE A WEASEL"
Charset = [" ", *"A".."Z"]
COPIES = 100

def random_char; Charset.sample end

def fitness(candidate)
  sum = 0
  candidate.chars.zip(@target.chars) {|x,y| sum += (x[0].ord - y[0].ord).abs}
  100.0 * Math.exp(Float(sum) / -10.0)
end

def mutation_rate(candidate)
  1.0 - Math.exp( -(100.0 - fitness(candidate)) / 400.0)
end

def mutate(parent, rate)
  parent.each_char.collect {|ch| rand <= rate ? random_char : ch}.join
end

def log(iteration, rate, parent)
  puts "%4d %.2f %5.1f %s" % [iteration, rate, fitness(parent), parent]
end

iteration = 0
parent = Array.new(@target.length) {random_char}.join
prev = ""

while parent != @target
  iteration += 1
  rate = mutation_rate(parent)
  if prev != parent
    log(iteration, rate, parent)
    prev = parent
  end
  copies = [parent] + Array.new(COPIES) {mutate(parent, rate)}
  parent = copies.max_by {|c| fitness(c)}
end
log(iteration, rate, parent)