DanielCujba/School
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

School Commit Init

Browse Source
This commit is contained in:
Daniel Cujba
2024-08-31 12:07:21 +03:00
commit 0b130ee18c
2801 changed files with 4720552 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Anul 2/Semestrul 2/AI/Lab8_unsolved.ipynb
+635
View File
@@ -0,0 +1,635 @@
{
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"# Lab 8: Evolutionary computation\n",
"\n",
"### Consider the following example:\n",
"\n",
"Determine the minimum of the function $f(x)= x_1^2+...+x_n^2$ with $x_i \\in [-5.12, 5.12]$, $i \\in \\overline{(1, n)}$\n",
"\n",
"We have an example of steady state genetic algorithm with: representation an array of real numbers; 100 individuals; crossover $$child = \\alpha \\cdot (parent1 - parent2) + parent2 ;$$ mutation - reinitialise on a random position the individual's value."
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Result: The detected minimum point after 10000 iterations is f(-0.00 -0.00) = 0.00\n"
]
}
],
"source": [
"\n",
"\n",
"from random import randint, random\n",
"from operator import add\n",
"from math import cos, pi\n",
"\n",
"\n",
"def individual(length, vmin, vmax):\n",
" '''\n",
" Create a member of the population - an individual\n",
"\n",
" length: the number of genes (components)\n",
" vmin: the minimum possible value \n",
" vmax: the maximum possible value \n",
" '''\n",
" return [ (random()*(vmax-vmin)+vmin) for x in range(length) ]\n",
" \n",
"def population(count, length, vmin, vmax):\n",
" \"\"\"\n",
" Create a number of individuals (i.e. a population).\n",
"\n",
" count: the number of individuals in the population\n",
" length: the number of values per individual\n",
" vmin: the minimum possible value \n",
" vmax: the maximum possible value \n",
" \"\"\"\n",
" return [ individual(length, vmin, vmax) for x in range(count) ]\n",
"\n",
"def fitness(individual):\n",
" \"\"\"\n",
" Determine the fitness of an individual. Lower is better.(min problem)\n",
" For this problem we have the Rastrigin function\n",
" \n",
" individual: the individual to evaluate\n",
" \"\"\"\n",
" n=len(individual)\n",
" f=0;\n",
" for i in range(n):\n",
" f=f+individual[i]*individual[i]\n",
" return f\n",
" \n",
"def mutate(individual, pM, vmin, vmax): \n",
" '''\n",
" Performs a mutation on an individual with the probability of pM.\n",
" If the event will take place, at a random position a new value will be\n",
" generated in the interval [vmin, vmax]\n",
"\n",
" individual:the individual to be mutated\n",
" pM: the probability the mutation to occure\n",
" vmin: the minimum possible value \n",
" vmax: the maximum possible value\n",
" '''\n",
" if pM > random():\n",
" p = randint(0, len(individual)-1)\n",
" individual[p] = random()*(vmax-vmin)+vmin\n",
" return individual\n",
" \n",
"def crossover(parent1, parent2):\n",
" '''\n",
" crossover between 2 parents\n",
" '''\n",
" child=[]\n",
" alpha=random()\n",
" for x in range(len(parent1)):\n",
" child.append(alpha*(parent1[x]-parent2[x])+parent2[x])\n",
" return child\n",
"\n",
"def iteration(pop, pM, vmin, vmax):\n",
" '''\n",
" an iteration\n",
"\n",
" pop: the current population\n",
" pM: the probability the mutation to occure\n",
" vmin: the minimum possible value \n",
" vmax: the maximum possible value\n",
" '''\n",
" i1=randint(0,len(pop)-1)\n",
" i2=randint(0,len(pop)-1)\n",
" if (i1!=i2):\n",
" c=crossover(pop[i1],pop[i2])\n",
" c=mutate(c, pM, vmin, vmax)\n",
" f1=fitness(pop[i1])\n",
" f2=fitness(pop[i2])\n",
" '''\n",
" the repeated evaluation of the parents can be avoided\n",
" if next to the values stored in the individuals we \n",
" keep also their fitnesses \n",
" '''\n",
" fc=fitness(c)\n",
" if(f1>f2) and (f1>fc):\n",
" pop[i1]=c\n",
" if(f2>f1) and (f2>fc):\n",
" pop[i2]=c\n",
" return pop\n",
"\n",
"def main(noIteratii=10000):\n",
" #PARAMETERS:\n",
" \n",
" #population size\n",
" dimPopulation = 100\n",
" #individual size\n",
" dimIndividual = 2\n",
" #the boundries of the search interval\n",
" vmin = -5.12\n",
" vmax = 5.12\n",
" #the mutation probability\n",
" pM=0.01\n",
" \n",
" P = population(dimPopulation, dimIndividual, vmin, vmax)\n",
" for i in range(noIteratii):\n",
" P = iteration(P, pM, vmin, vmax)\n",
"\n",
" #print the best individual\n",
" graded = [ (fitness(x), x) for x in P]\n",
" graded = sorted(graded)\n",
" result=graded[0]\n",
" fitnessOptim=result[0]\n",
" individualOptim=result[1]\n",
" print('Result: The detected minimum point after %d iterations is f(%3.2f %3.2f) = %3.2f'% \\\n",
" (noIteratii,individualOptim[0],individualOptim[1], fitnessOptim) )\n",
" \n",
"main()"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Exercise 1: Construct a similar algorithm to the one provided as an example for the Bukin function N.6 (search the internet for this function).\n"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Result: The detected minimum point after 10000 iterations is f(-9.81 0.96) = 0.00\n",
"0.0\n"
]
}
],
"source": [
"# your code here\n",
"\n",
"\n",
"from random import randint, random\n",
"from operator import add\n",
"from math import cos, pi\n",
"\n",
"\n",
"def individual():\n",
" return [ (random()*(-5+15)-15), (random()*(3+3)-3)]\n",
" \n",
"def population(count):\n",
" return [ individual() for x in range(count) ]\n",
"\n",
"def fitness(individual):\n",
" return (100 *((abs(individual[1] - 0.01*(individual[0]**2)))**(1/2))) + (0.01 * abs(individual[0] + 10))\n",
" \n",
"def mutate(individual, pM): \n",
" if pM > random():\n",
" p = randint(0, 1)\n",
" if p == 0:\n",
" individual[0] = random()*(-5+15)-15\n",
" else:\n",
" individual[1] = random()*(3+3)-3\n",
" return individual\n",
" \n",
"def crossover(parent1, parent2):\n",
" child=[]\n",
" alpha=random()\n",
" for x in range(len(parent1)):\n",
" child.append(alpha*(parent1[x]-parent2[x])+parent2[x])\n",
" return child\n",
"\n",
"def iteration(pop, pM):\n",
" i1=randint(0,len(pop)-1)\n",
" i2=randint(0,len(pop)-1)\n",
" if (i1!=i2):\n",
" c=crossover(pop[i1],pop[i2])\n",
" c=mutate(c, pM)\n",
" f1=fitness(pop[i1])\n",
" f2=fitness(pop[i2])\n",
" fc=fitness(c)\n",
" if(f1>f2) and (f1>fc):\n",
" pop[i1]=c\n",
" if(f2>f1) and (f2>fc):\n",
" pop[i2]=c\n",
" return pop\n",
"\n",
"def main(noIteratii=10000):\n",
" #PARAMETERS:\n",
" \n",
" #population size\n",
" dimPopulation = 100\n",
" #the mutation probability\n",
" pM=0.01\n",
" \n",
" P = population(dimPopulation)\n",
" for i in range(noIteratii):\n",
" P = iteration(P, pM)\n",
"\n",
" #print the best individual\n",
" graded = [ (fitness(x), x) for x in P]\n",
" graded = sorted(graded)\n",
" result=graded[0]\n",
" fitnessOptim=result[0]\n",
" individualOptim=result[1]\n",
" print('Result: The detected minimum point after %d iterations is f(%3.2f %3.2f) = %3.2f'% \\\n",
" (noIteratii,individualOptim[0],individualOptim[1], fitnessOptim) )\n",
" print(fitness((-10,1)))\n",
"main()"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Consider the knapsack problem:\n",
"\n",
"Consider a Knapsack with a total volum equal with $V_{max}$.\n",
"\n",
"There are $n$ objects, with values $(p_i)_{n}$ and volumes $(v_i)_n$.\n",
"\n",
"Solve this problem using a generationist Genetic Algorithm, with a binary representation.\n",
"\n",
"Exercise 2: Initialization\n",
"Objective: Implement the initialization step of a genetic algorithm."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0 1 0 0 1 1 1 0]\n",
" [0 1 0 1 0 1 0 0]\n",
" [0 1 0 1 0 1 0 1]\n",
" [1 0 0 0 0 0 0 1]\n",
" [0 1 0 1 0 1 1 1]\n",
" [0 1 0 1 0 1 1 1]\n",
" [1 1 0 0 1 1 0 0]\n",
" [1 0 0 0 0 0 1 0]\n",
" [1 0 0 1 0 0 1 0]\n",
" [1 1 1 1 0 0 0 0]]\n"
]
}
],
"source": [
"import random\n",
"import numpy as np\n",
"\n",
"def individual(chromosome_length):\n",
" return np.array([randint(0,1) for _ in range(chromosome_length)])\n",
"\n",
"def initialize_population(population_size, chromosome_length):\n",
" # generate random a population with population_size number of individuals\n",
" # each individual with the size chromosome_length\n",
" # IN: population_size, chromosome_length\n",
" # OUT: population\n",
" return np.array([individual(chromosome_length) for _ in range(population_size)])\n",
" # your code here\n",
"\n",
"\n",
"\n",
"\n",
"# Test the initialization step\n",
"population_size = 10\n",
"chromosome_length = 8\n",
"weights = np.array([1, 4, 5, 7, 3, 2, 4 ,1])\n",
"values = np.array([2, 3, 1, 4, 2, 3, 4, 5])\n",
"limit = 14\n",
"population = initialize_population(population_size, chromosome_length)\n",
"print(population)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Exercise 3: Fitness Evaluation\n",
"\n",
"Objective: Implement the fitness evaluation step of a genetic algorithm."
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[12 10 15 7 0 0 10 6 10 0]\n"
]
}
],
"source": [
"def evaluate_fitness(population):\n",
" # evaluate the fitness of each individual in the population\n",
" # IN: population\n",
" # OUT: fitness_scores\n",
" # your code here\n",
" total_weights = (weights * population).sum(axis=1)\n",
" scores = (values * population).sum(axis=1)\n",
" scores[total_weights > limit] = 0\n",
" return scores\n",
" \n",
"# Test the fitness evaluation step\n",
"fitness_scores = evaluate_fitness(population)\n",
"print(fitness_scores)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Exercise 4: Selection\n",
"\n",
"Objective: Implement the selection step of a genetic algorithm."
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0 1 0 1 0 1 0 0]\n",
" [0 1 0 1 0 1 0 1]]\n"
]
}
],
"source": [
"def select_parents(population, fitness_scores):\n",
" # select two parents from the population based on the fitness - \n",
" # the better the fitness, the higher the chance to be selected\n",
" # IN: population, fitness_scores\n",
" # OUT: selected_parents\n",
" # your code here\n",
" probs = ((fitness_scores + 1) / (fitness_scores + 1).sum())\n",
" indexes = np.random.choice(population.shape[0], size = 2, replace=False, p=probs)\n",
" return population[indexes]\n",
" \n",
"# Test the selection step\n",
"parents = select_parents(population, fitness_scores)\n",
"print(parents)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Exercise 5: Crossover\n",
"\n",
"Objective: Implement the crossover step of a genetic algorithm."
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0. 1. 0. 1. 0. 1. 0. 1.]\n"
]
}
],
"source": [
"def crossover(parents):\n",
" # create new offspring by combining the parents\n",
" # IN: parents\n",
" # OUT: offspring\n",
"\n",
" # your code here\n",
" offspring = np.zeros((parents.shape[1],))\n",
" for i in range(parents.shape[1]):\n",
" if parents[0][i] == parents[1][i]:\n",
" offspring[i] = parents[0][i]\n",
" else:\n",
" offspring[i] = random.randint(0, 1)\n",
" return offspring\n",
"\n",
"\n",
"# Test the crossover step\n",
"offspring = crossover(parents)\n",
"print(offspring)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Exercise 6: Mutation\n",
"\n",
"Objective: Implement the mutation step of a genetic algorithm."
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0]\n"
]
}
],
"source": [
"def mutate(chromosome, mutation_rate):\n",
" # mutate the chromosome by randomly flipping bits\n",
" # IN: chromosome, mutation_rate\n",
" # OUT: mutated_chromosome\n",
"\n",
" # your code here\n",
" if random.random() <= mutation_rate:\n",
" for i in range(len(chromosome)):\n",
" chromosome[i] = random.randint(0, 1)\n",
" return chromosome\n",
"\n",
"\n",
"# Test the mutation step\n",
"mutation_rate = 0.1\n",
"mutated_offspring = [mutate(child, mutation_rate) for child in offspring]\n",
"print(mutated_offspring)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Exercise 7: Complete Genetic Algorithm\n",
"\n",
"Objective: Combine all the steps of a genetic algorithm to solve a specific problem."
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1 1 0 0 0 1 1 1]\n",
" [1 1 0 0 0 1 1 1]\n",
" [1 1 0 0 0 1 1 1]\n",
" [1 1 0 0 0 1 1 1]\n",
" [1 1 0 0 0 1 1 1]\n",
" [1 1 0 0 0 1 1 1]\n",
" [1 1 0 0 0 1 1 1]\n",
" [1 1 0 0 0 1 1 1]\n",
" [1 1 0 0 0 1 1 1]\n",
" [1 1 0 0 0 1 1 1]]\n"
]
}
],
"source": [
"def genetic_algorithm(population_size, chromosome_length, generations, mutation_rate):\n",
" \n",
" # complete genetic algorithm\n",
" # IN: population_size, chromosome_length, generations, mutation_rate\n",
" # OUT: population\n",
"\n",
"\n",
" # initialize the population\n",
" population = initialize_population(population_size, chromosome_length)\n",
" # your code here\n",
" \n",
"\n",
" for _ in range(generations):\n",
" # Fitness evaluation\n",
" # your code here\n",
" fitnesses = evaluate_fitness(population)\n",
" \n",
" # Selection\n",
" \n",
" # your code here\n",
" parents = select_parents(population, fitnesses)\n",
"\n",
" # Crossover\n",
"\n",
" # your code here\n",
" child = crossover(parents)\n",
"\n",
" # Mutation\n",
" \n",
" # your code here\n",
" mutated_child = mutate(child, mutation_rate)\n",
"\n",
" # Replace the population with the new generation\n",
" \n",
" # your code here\n",
" minimum = fitnesses.min()\n",
" for i in range(fitnesses.shape[0]):\n",
" if minimum == fitnesses[i]:\n",
" population[i] = mutated_child\n",
" break\n",
"\n",
" return population\n",
"\n",
"# Test the complete genetic algorithm\n",
"population_size = 10\n",
"chromosome_length = 8\n",
"generations = 100\n",
"mutation_rate = 0.1\n",
"\n",
"final_population = genetic_algorithm(population_size, chromosome_length, generations, mutation_rate)\n",
"print(final_population)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Exercise 8: Extract the result from the final population\n",
"\n",
"Objective: Get the best individual from the final population.\n"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Maximum is 17\n",
"Chosen values [2 3 0 0 0 3 4 5] with weights [1 4 0 0 0 2 4 1]\n"
]
}
],
"source": [
"# determine the best individual from the final population and print it out\n",
"\n",
"# your code here\n",
"\n",
"fitnesses = evaluate_fitness(final_population)\n",
"maximum = fitnesses.max()\n",
"print(f\"Maximum is {maximum}\")\n",
"for i in range(0, fitnesses.shape[0]):\n",
" if fitnesses[i] == maximum:\n",
" print(f\"Chosen values {final_population[i] * values} with weights {final_population[i] * weights}\")\n",
" break"
]
}
],
"metadata": {
"kernel_info": {
"name": "python"
},
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.2"
},
"nteract": {
"version": "nteract-front-end@1.0.0"
},
"orig_nbformat": 4
},
"nbformat": 4,
"nbformat_minor": 2
}