class Node:\n",
"\n",
" """A node in a search tree. Contains a pointer to the parent (the node\n",
" that this is a successor of) and to the actual state for this node. Note\n",
" that if a state is arrived at by two paths, then there are two nodes with\n",
" the same state. Also includes the action that got us to this state, and\n",
" the total path_cost (also known as g) to reach the node. Other functions\n",
" may add an f and h value; see best_first_graph_search and astar_search for\n",
" an explanation of how the f and h values are handled. You will not need to\n",
" subclass this class."""\n",
"\n",
" def __init__(self, state, parent=None, action=None, path_cost=0):\n",
" """Create a search tree Node, derived from a parent by an action."""\n",
" self.state = state\n",
" self.parent = parent\n",
" self.action = action\n",
" self.path_cost = path_cost\n",
" self.depth = 0\n",
" if parent:\n",
" self.depth = parent.depth + 1\n",
"\n",
" def __repr__(self):\n",
" return "<Node {}>".format(self.state)\n",
"\n",
" def __lt__(self, node):\n",
" return self.state < node.state\n",
"\n",
" def expand(self, problem):\n",
" """List the nodes reachable in one step from this node."""\n",
" return [self.child_node(problem, action)\n",
" for action in problem.actions(self.state)]\n",
"\n",
" def child_node(self, problem, action):\n",
" """[Figure 3.10]"""\n",
" next = problem.result(self.state, action)\n",
" return Node(next, self, action,\n",
" problem.path_cost(self.path_cost, self.state,\n",
" action, next))\n",
"\n",
" def solution(self):\n",
" """Return the sequence of actions to go from the root to this node."""\n",
" return [node.action for node in self.path()[1:]]\n",
"\n",
" def path(self):\n",
" """Return a list of nodes forming the path from the root to this node."""\n",
" node, path_back = self, []\n",
" while node:\n",
" path_back.append(node)\n",
" node = node.parent\n",
" return list(reversed(path_back))\n",
"\n",
" # We want for a queue of nodes in breadth_first_search or\n",
" # astar_search to have no duplicated states, so we treat nodes\n",
" # with the same state as equal. [Problem: this may not be what you\n",
" # want in other contexts.]\n",
"\n",
" def __eq__(self, other):\n",
" return isinstance(other, Node) and self.state == other.state\n",
"\n",
" def __hash__(self):\n",
" return hash(self.state)\n",
"class GraphProblem(Problem):\n",
"\n",
" """The problem of searching a graph from one node to another."""\n",
"\n",
" def __init__(self, initial, goal, graph):\n",
" Problem.__init__(self, initial, goal)\n",
" self.graph = graph\n",
"\n",
" def actions(self, A):\n",
" """The actions at a graph node are just its neighbors."""\n",
" return list(self.graph.get(A).keys())\n",
"\n",
" def result(self, state, action):\n",
" """The result of going to a neighbor is just that neighbor."""\n",
" return action\n",
"\n",
" def path_cost(self, cost_so_far, A, action, B):\n",
" return cost_so_far + (self.graph.get(A, B) or infinity)\n",
"\n",
" def find_min_edge(self):\n",
" """Find minimum value of edges."""\n",
" m = infinity\n",
" for d in self.graph.dict.values():\n",
" local_min = min(d.values())\n",
" m = min(m, local_min)\n",
"\n",
" return m\n",
"\n",
" def h(self, node):\n",
" """h function is straight-line distance from a node's state to goal."""\n",
" locs = getattr(self.graph, 'locations', None)\n",
" if locs:\n",
" if type(node) is str:\n",
" return int(distance(locs[node], locs[self.goal]))\n",
"\n",
" return int(distance(locs[node.state], locs[self.goal]))\n",
" else:\n",
" return infinity\n",
"class SimpleProblemSolvingAgentProgram:\n",
"\n",
" """Abstract framework for a problem-solving agent. [Figure 3.1]"""\n",
"\n",
" def __init__(self, initial_state=None):\n",
" """State is an abstract representation of the state\n",
" of the world, and seq is the list of actions required\n",
" to get to a particular state from the initial state(root)."""\n",
" self.state = initial_state\n",
" self.seq = []\n",
"\n",
" def __call__(self, percept):\n",
" """[Figure 3.1] Formulate a goal and problem, then\n",
" search for a sequence of actions to solve it."""\n",
" self.state = self.update_state(self.state, percept)\n",
" if not self.seq:\n",
" goal = self.formulate_goal(self.state)\n",
" problem = self.formulate_problem(self.state, goal)\n",
" self.seq = self.search(problem)\n",
" if not self.seq:\n",
" return None\n",
" return self.seq.pop(0)\n",
"\n",
" def update_state(self, percept):\n",
" raise NotImplementedError\n",
"\n",
" def formulate_goal(self, state):\n",
" raise NotImplementedError\n",
"\n",
" def formulate_problem(self, state, goal):\n",
" raise NotImplementedError\n",
"\n",
" def search(self, problem):\n",
" raise NotImplementedError\n",
"
\n",
"As a whole, the algorithm works as follows:\n",
"- Evaluate the initial state.\n",
"- If it is equal to the goal state, return.\n",
"- Find a neighboring state (one which is heuristically similar to the current state)\n",
"- Evaluate this state. If it is closer to the goal state than before, replace the initial state with this state and repeat these steps.\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"\n",
" \n",
" \n",
" \n",
"\n",
"\n",
"\n",
"\n",
"def hill_climbing(problem):\n",
" """From the initial node, keep choosing the neighbor with highest value,\n",
" stopping when no neighbor is better. [Figure 4.2]"""\n",
" current = Node(problem.initial)\n",
" while True:\n",
" neighbors = current.expand(problem)\n",
" if not neighbors:\n",
" break\n",
" neighbor = argmax_random_tie(neighbors,\n",
" key=lambda node: problem.value(node.state))\n",
" if problem.value(neighbor.state) <= problem.value(current.state):\n",
" break\n",
" current = neighbor\n",
" return current.state\n",
"
\n",
"We need to define a class for this problem.\n",
"
\n",
"`Problem` will be used as a base class."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"class TSP_problem(Problem):\n",
"\n",
" \"\"\" subclass of Problem to define various functions \"\"\"\n",
"\n",
" def two_opt(self, state):\n",
" \"\"\" Neighbour generating function for Traveling Salesman Problem \"\"\"\n",
" neighbour_state = state[:]\n",
" left = random.randint(0, len(neighbour_state) - 1)\n",
" right = random.randint(0, len(neighbour_state) - 1)\n",
" if left > right:\n",
" left, right = right, left\n",
" neighbour_state[left: right + 1] = reversed(neighbour_state[left: right + 1])\n",
" return neighbour_state\n",
"\n",
" def actions(self, state):\n",
" \"\"\" action that can be excuted in given state \"\"\"\n",
" return [self.two_opt]\n",
"\n",
" def result(self, state, action):\n",
" \"\"\" result after applying the given action on the given state \"\"\"\n",
" return action(state)\n",
"\n",
" def path_cost(self, c, state1, action, state2):\n",
" \"\"\" total distance for the Traveling Salesman to be covered if in state2 \"\"\"\n",
" cost = 0\n",
" for i in range(len(state2) - 1):\n",
" cost += distances[state2[i]][state2[i + 1]]\n",
" cost += distances[state2[0]][state2[-1]]\n",
" return cost\n",
"\n",
" def value(self, state):\n",
" \"\"\" value of path cost given negative for the given state \"\"\"\n",
" return -1 * self.path_cost(None, None, None, state)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We will use cities from the Romania map as our cities for this problem.\n",
"
\n",
"A list of all cities and a dictionary storing distances between them will be populated."
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['Arad', 'Bucharest', 'Craiova', 'Drobeta', 'Eforie', 'Fagaras', 'Giurgiu', 'Hirsova', 'Iasi', 'Lugoj', 'Mehadia', 'Neamt', 'Oradea', 'Pitesti', 'Rimnicu', 'Sibiu', 'Timisoara', 'Urziceni', 'Vaslui', 'Zerind']\n"
]
}
],
"source": [
"distances = {}\n",
"all_cities = []\n",
"\n",
"for city in romania_map.locations.keys():\n",
" distances[city] = {}\n",
" all_cities.append(city)\n",
" \n",
"all_cities.sort()\n",
"print(all_cities)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Next, we need to populate the individual lists inside the dictionary with the manhattan distance between the cities."
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"import numpy as np\n",
"for name_1, coordinates_1 in romania_map.locations.items():\n",
" for name_2, coordinates_2 in romania_map.locations.items():\n",
" distances[name_1][name_2] = np.linalg.norm(\n",
" [coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])\n",
" distances[name_2][name_1] = np.linalg.norm(\n",
" [coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The way neighbours are chosen currently isn't suitable for the travelling salespersons problem.\n",
"We need a neighboring state that is similar in total path distance to the current state.\n",
"
\n",
"We need to change the function that finds neighbors."
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def hill_climbing(problem):\n",
" \n",
" \"\"\"From the initial node, keep choosing the neighbor with highest value,\n",
" stopping when no neighbor is better. [Figure 4.2]\"\"\"\n",
" \n",
" def find_neighbors(state, number_of_neighbors=100):\n",
" \"\"\" finds neighbors using two_opt method \"\"\"\n",
" \n",
" neighbors = []\n",
" \n",
" for i in range(number_of_neighbors):\n",
" new_state = problem.two_opt(state)\n",
" neighbors.append(Node(new_state))\n",
" state = new_state\n",
" \n",
" return neighbors\n",
"\n",
" # as this is a stochastic algorithm, we will set a cap on the number of iterations\n",
" iterations = 10000\n",
" \n",
" current = Node(problem.initial)\n",
" while iterations:\n",
" neighbors = find_neighbors(current.state)\n",
" if not neighbors:\n",
" break\n",
" neighbor = argmax_random_tie(neighbors,\n",
" key=lambda node: problem.value(node.state))\n",
" if problem.value(neighbor.state) <= problem.value(current.state):\n",
" current.state = neighbor.state\n",
" iterations -= 1\n",
" \n",
" return current.state"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"An instance of the TSP_problem class will be created."
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"tsp = TSP_problem(all_cities)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can now generate an approximate solution to the problem by calling `hill_climbing`.\n",
"The results will vary a bit each time you run it."
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['Fagaras',\n",
" 'Neamt',\n",
" 'Iasi',\n",
" 'Vaslui',\n",
" 'Hirsova',\n",
" 'Eforie',\n",
" 'Urziceni',\n",
" 'Bucharest',\n",
" 'Giurgiu',\n",
" 'Pitesti',\n",
" 'Craiova',\n",
" 'Drobeta',\n",
" 'Mehadia',\n",
" 'Lugoj',\n",
" 'Timisoara',\n",
" 'Arad',\n",
" 'Zerind',\n",
" 'Oradea',\n",
" 'Sibiu',\n",
" 'Rimnicu']"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"hill_climbing(tsp)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The solution looks like this.\n",
"It is not difficult to see why this might be a good solution.\n",
"
\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## GENETIC ALGORITHM\n",
"\n",
"Genetic algorithms (or GA) are inspired by natural evolution and are particularly useful in optimization and search problems with large state spaces.\n",
"\n",
"Given a problem, algorithms in the domain make use of a *population* of solutions (also called *states*), where each solution/state represents a feasible solution. At each iteration (often called *generation*), the population gets updated using methods inspired by biology and evolution, like *crossover*, *mutation* and *natural selection*."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Overview\n",
"\n",
"A genetic algorithm works in the following way:\n",
"\n",
"1) Initialize random population.\n",
"\n",
"2) Calculate population fitness.\n",
"\n",
"3) Select individuals for mating.\n",
"\n",
"4) Mate selected individuals to produce new population.\n",
"\n",
" * Random chance to mutate individuals.\n",
"\n",
"5) Repeat from step 2) until an individual is fit enough or the maximum number of iterations was reached."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Glossary\n",
"\n",
"Before we continue, we will lay the basic terminology of the algorithm.\n",
"\n",
"* Individual/State: A list of elements (called *genes*) that represent possible solutions.\n",
"\n",
"* Population: The list of all the individuals/states.\n",
"\n",
"* Gene pool: The alphabet of possible values for an individual's genes.\n",
"\n",
"* Generation/Iteration: The number of times the population will be updated.\n",
"\n",
"* Fitness: An individual's score, calculated by a function specific to the problem."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Crossover\n",
"\n",
"Two individuals/states can \"mate\" and produce one child. This offspring bears characteristics from both of its parents. There are many ways we can implement this crossover. Here we will take a look at the most common ones. Most other methods are variations of those below.\n",
"\n",
"* Point Crossover: The crossover occurs around one (or more) point. The parents get \"split\" at the chosen point or points and then get merged. In the example below we see two parents get split and merged at the 3rd digit, producing the following offspring after the crossover.\n",
"\n",
"\n",
"\n",
"* Uniform Crossover: This type of crossover chooses randomly the genes to get merged. Here the genes 1, 2 and 5 were chosen from the first parent, so the genes 3, 4 were added by the second parent.\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Mutation\n",
"\n",
"When an offspring is produced, there is a chance it will mutate, having one (or more, depending on the implementation) of its genes altered.\n",
"\n",
"For example, let's say the new individual to undergo mutation is \"abcde\". Randomly we pick to change its third gene to 'z'. The individual now becomes \"abzde\" and is added to the population."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Selection\n",
"\n",
"At each iteration, the fittest individuals are picked randomly to mate and produce offsprings. We measure an individual's fitness with a *fitness function*. That function depends on the given problem and it is used to score an individual. Usually the higher the better.\n",
"\n",
"The selection process is this:\n",
"\n",
"1) Individuals are scored by the fitness function.\n",
"\n",
"2) Individuals are picked randomly, according to their score (higher score means higher chance to get picked). Usually the formula to calculate the chance to pick an individual is the following (for population *P* and individual *i*):\n",
"\n",
"$$ chance(i) = \\dfrac{fitness(i)}{\\sum_{k \\, in \\, P}{fitness(k)}} $$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Implementation\n",
"\n",
"Below we look over the implementation of the algorithm in the `search` module.\n",
"\n",
"First the implementation of the main core of the algorithm:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"\n",
" \n",
" \n",
" \n",
"\n",
"\n",
"\n",
"\n",
"def genetic_algorithm(population, fitness_fn, gene_pool=[0, 1], f_thres=None, ngen=1000, pmut=0.1):\n",
" """[Figure 4.8]"""\n",
" for i in range(ngen):\n",
" population = [mutate(recombine(*select(2, population, fitness_fn)), gene_pool, pmut)\n",
" for i in range(len(population))]\n",
"\n",
" fittest_individual = fitness_threshold(fitness_fn, f_thres, population)\n",
" if fittest_individual:\n",
" return fittest_individual\n",
"\n",
"\n",
" return argmax(population, key=fitness_fn)\n",
"def recombine(x, y):\n",
" n = len(x)\n",
" c = random.randrange(0, n)\n",
" return x[:c] + y[c:]\n",
"def mutate(x, gene_pool, pmut):\n",
" if random.uniform(0, 1) >= pmut:\n",
" return x\n",
"\n",
" n = len(x)\n",
" g = len(gene_pool)\n",
" c = random.randrange(0, n)\n",
" r = random.randrange(0, g)\n",
"\n",
" new_gene = gene_pool[r]\n",
" return x[:c] + [new_gene] + x[c+1:]\n",
"def init_population(pop_number, gene_pool, state_length):\n",
" """Initializes population for genetic algorithm\n",
" pop_number : Number of individuals in population\n",
" gene_pool : List of possible values for individuals\n",
" state_length: The length of each individual"""\n",
" g = len(gene_pool)\n",
" population = []\n",
" for i in range(pop_number):\n",
" new_individual = [gene_pool[random.randrange(0, g)] for j in range(state_length)]\n",
" population.append(new_individual)\n",
"\n",
" return population\n",
"
\n",
"For this particular problem, two strings from the population will be chosen as parents and will be split at a random index and recombined as described in the `recombine` function to create a child. This child string will then be added to the new generation.\n",
"\n",
"\n",
"* **Variation**: There must be a variety of traits present in the population or a means with which to introduce variation.
If there is no variation in the sample space, we might never reach the global optimum. To ensure that there is enough variation, we can initialize a large population, but this gets computationally expensive as the population gets larger. Hence, we often use another method called mutation. In this method, we randomly change one or more characters of some strings in the population based on a predefined probability value called the mutation rate or mutation probability as described in the `mutate` function. The mutation rate is usually kept quite low. A mutation rate of zero fails to introduce variation in the population and a high mutation rate (say 50%) is as good as a coin flip and the population fails to benefit from the previous recombinations. An optimum balance has to be maintained between population size and mutation rate so as to reduce the computational cost as well as have sufficient variation in the population.\n",
"\n",
"\n",
"* **Selection**: There must be some mechanism by which some members of the population have the opportunity to be parents and pass down their genetic information and some do not. This is typically referred to as \"survival of the fittest\".
\n",
"There has to be some way of determining which phrases in our population have a better chance of eventually evolving into the target phrase. This is done by introducing a fitness function that calculates how close the generated phrase is to the target phrase. The function will simply return a scalar value corresponding to the number of matching characters between the generated phrase and the target phrase."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Before solving the problem, we first need to define our target phrase."
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"target = 'Genetic Algorithm'"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"We then need to define our gene pool, i.e the elements which an individual from the population might comprise of. Here, the gene pool contains all uppercase and lowercase letters of the English alphabet and the space character."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# The ASCII values of uppercase characters ranges from 65 to 91\n",
"u_case = [chr(x) for x in range(65, 91)]\n",
"# The ASCII values of lowercase characters ranges from 97 to 123\n",
"l_case = [chr(x) for x in range(97, 123)]\n",
"\n",
"gene_pool = []\n",
"gene_pool.extend(u_case) # adds the uppercase list to the gene pool\n",
"gene_pool.extend(l_case) # adds the lowercase list to the gene pool\n",
"gene_pool.append(' ') # adds the space character to the gene pool"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We now need to define the maximum size of each population. Larger populations have more variation but are computationally more expensive to run algorithms on."
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"max_population = 100"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As our population is not very large, we can afford to keep a relatively large mutation rate."
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"mutation_rate = 0.07 # 7%"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Great! Now, we need to define the most important metric for the genetic algorithm, i.e the fitness function. This will simply return the number of matching characters between the generated sample and the target phrase."
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def fitness_fn(sample):\n",
" # initialize fitness to 0\n",
" fitness = 0\n",
" for i in range(len(sample)):\n",
" # increment fitness by 1 for every matching character\n",
" if sample[i] == target[i]:\n",
" fitness += 1\n",
" return fitness"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Before we run our genetic algorithm, we need to initialize a random population. We will use the `init_population` function to do this. We need to pass in the maximum population size, the gene pool and the length of each individual, which in this case will be the same as the length of the target phrase."
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"population = init_population(max_population, gene_pool, len(target))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We will now define how the individuals in the population should change as the number of generations increases. First, the `select` function will be run on the population to select *two* individuals with high fitness values. These will be the parents which will then be recombined using the `recombine` function to generate the child."
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"parents = select(2, population, fitness_fn) "
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# The recombine function takes two parents as arguments, so we need to unpack the previous variable\n",
"child = recombine(*parents)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Next, we need to apply a mutation according to the mutation rate. We call the `mutate` function on the child with the gene pool and mutation rate as the additional arguments."
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"child = mutate(child, gene_pool, mutation_rate)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The above lines can be condensed into\n",
"\n",
"`child = mutate(recombine(*select(2, population, fitness_fn)), gene_pool, mutation_rate)`\n",
"\n",
"And, we need to do this `for` every individual in the current population to generate the new population."
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"population = [mutate(recombine(*select(2, population, fitness_fn)), gene_pool, mutation_rate) for i in range(len(population))]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The individual with the highest fitness can then be found using the `max` function."
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"current_best = max(population, key=fitness_fn)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's print this out"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['j', 'F', 'm', 'F', 'N', 'i', 'c', 'v', 'm', 'j', 'V', 'o', 'd', 'r', 't', 'V', 'H']\n"
]
}
],
"source": [
"print(current_best)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We see that this is a list of characters. This can be converted to a string using the join function"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"jFmFNicvmjVodrtVH\n"
]
}
],
"source": [
"current_best_string = ''.join(current_best)\n",
"print(current_best_string)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We now need to define the conditions to terminate the algorithm. This can happen in two ways\n",
"1. Termination after a predefined number of generations\n",
"2. Termination when the fitness of the best individual of the current generation reaches a predefined threshold value.\n",
"\n",
"We define these variables below"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"ngen = 1200 # maximum number of generations\n",
"# we set the threshold fitness equal to the length of the target phrase\n",
"# i.e the algorithm only terminates whne it has got all the characters correct \n",
"# or it has completed 'ngen' number of generations\n",
"f_thres = len(target)"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"To generate `ngen` number of generations, we run a `for` loop `ngen` number of times. After each generation, we calculate the fitness of the best individual of the generation and compare it to the value of `f_thres` using the `fitness_threshold` function. After every generation, we print out the best individual of the generation and the corresponding fitness value. Lets now write a function to do this."
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def genetic_algorithm_stepwise(population, fitness_fn, gene_pool=[0, 1], f_thres=None, ngen=1200, pmut=0.1):\n",
" for generation in range(ngen):\n",
" population = [mutate(recombine(*select(2, population, fitness_fn)), gene_pool, pmut) for i in range(len(population))]\n",
" # stores the individual genome with the highest fitness in the current population\n",
" current_best = ''.join(max(population, key=fitness_fn))\n",
" print(f'Current best: {current_best}\\t\\tGeneration: {str(generation)}\\t\\tFitness: {fitness_fn(current_best)}\\r', end='')\n",
" \n",
" # compare the fitness of the current best individual to f_thres\n",
" fittest_individual = fitness_threshold(fitness_fn, f_thres, population)\n",
" \n",
" # if fitness is greater than or equal to f_thres, we terminate the algorithm\n",
" if fittest_individual:\n",
" return fittest_individual, generation\n",
" return max(population, key=fitness_fn) , generation "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The function defined above is essentially the same as the one defined in `search.py` with the added functionality of printing out the data of each generation."
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
"\n",
" \n",
" \n",
" \n",
"\n",
"\n",
"\n",
"\n",
"def genetic_algorithm(population, fitness_fn, gene_pool=[0, 1], f_thres=None, ngen=1000, pmut=0.1):\n",
" """[Figure 4.8]"""\n",
" for i in range(ngen):\n",
" population = [mutate(recombine(*select(2, population, fitness_fn)), gene_pool, pmut)\n",
" for i in range(len(population))]\n",
"\n",
" fittest_individual = fitness_threshold(fitness_fn, f_thres, population)\n",
" if fittest_individual:\n",
" return fittest_individual\n",
"\n",
"\n",
" return argmax(population, key=fitness_fn)\n",
"