evolutionary-algorithms-from-scratch-v1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a875d490",
   "metadata": {},
   "source": [
    "# Evolutionary algorithm based search for the \"Knapsack problem\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1292c3c",
   "metadata": {},
   "source": [
    "## I. Generating data for the knapsack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "35f3ba83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pearl     weight:3, value:4$\n",
      "gold bar  weight:7, value:7$\n",
      "crown     weight:4, value:5$\n",
      "coin      weight:1, value:1$\n",
      "axe       weight:5, value:4$\n",
      "sword     weight:4, value:3$\n",
      "ring      weight:2, value:5$\n",
      "cup       weight:3, value:1$\n"
     ]
    }
   ],
   "source": [
    "# Dataset for a small knapsack\n",
    "s_items = \"pearl, gold bar, crown, coin, axe, sword, ring, cup\"\n",
    "s_items = [item.strip() for item in s_items.split(',')]\n",
    "s_weights = [3, 7, 4, 1, 5, 4, 2, 3]\n",
    "s_prices = [4, 7, 5, 1, 4, 3, 5, 1]\n",
    "\n",
    "# Creating an items list with the following format for each entry---> (item, weight, value)\n",
    "small_items_list = list(zip(s_items,s_weights,s_prices))\n",
    "\n",
    "# Packaging the list with other parameters\n",
    "s_max_weight = 9 # Maximum weight allowed for the knapsack\n",
    "s_optimal_value = 14 # Value for the optimal solution\n",
    "small_items_package = small_items_list, s_max_weight, s_optimal_value\n",
    "\n",
    "# Viewing the contents of the small items list\n",
    "for item in small_items_list:\n",
    "    print(f\"{item[0]:<10}weight:{item[1]}, value:{item[2]}$\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "56ca350b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Axe                 weight:32252      value:68674$\n",
      "Bronze coin         weight:225790     value:471010$\n",
      "Crown               weight:468164     value:944620$\n",
      "Diamond statue      weight:489494     value:962094$\n",
      "Emerald belt        weight:35384      value:78344$\n",
      "Fossil              weight:265590     value:579152$\n",
      "Gold coin           weight:497911     value:902698$\n",
      "Helmet              weight:800493     value:1686515$\n",
      "Ink                 weight:823576     value:1688691$\n",
      "Jewel box           weight:552202     value:1056157$\n",
      "Knife               weight:323618     value:677562$\n",
      "Long sword          weight:382846     value:833132$\n",
      "Mask                weight:44676      value:99192$\n",
      "Necklace            weight:169738     value:376418$\n",
      "Opal badge          weight:610876     value:1253986$\n",
      "Pearls              weight:854190     value:1853562$\n",
      "Quiver              weight:671123     value:1320297$\n",
      "Ruby ring           weight:698180     value:1301637$\n",
      "Silver bracelet     weight:446517     value:859835$\n",
      "Timepiece           weight:909620     value:1677534$\n",
      "Uniform             weight:904818     value:1910501$\n",
      "Venom potion        weight:730061     value:1528646$\n",
      "Wool scarf          weight:931932     value:1827477$\n",
      "Crossbow            weight:952360     value:2068204$\n",
      "Yesteryear book     weight:926023     value:1746556$\n",
      "Zinc cup            weight:978724     value:2100851$\n"
     ]
    }
   ],
   "source": [
    "# Dataset for a large knapsack\n",
    "large_items_data = '''1\n",
    "Axe\n",
    "32,252\n",
    "68,674\n",
    "2\n",
    "Bronze coin\n",
    "225,790\n",
    "471,010\n",
    "3\n",
    "Crown\n",
    "468,164\n",
    "944,620\n",
    "4\n",
    "Diamond statue\n",
    "489,494\n",
    "962,094\n",
    "5\n",
    "Emerald belt\n",
    "35,384\n",
    "78,344\n",
    "6\n",
    "Fossil\n",
    "265,590\n",
    "579,152\n",
    "7\n",
    "Gold coin\n",
    "497,911\n",
    "902,698\n",
    "8\n",
    "Helmet\n",
    "800,493\n",
    "1,686,515\n",
    "9\n",
    "Ink\n",
    "823,576\n",
    "1,688,691\n",
    "10\n",
    "Jewel box\n",
    "552,202\n",
    "1,056,157\n",
    "11\n",
    "Knife\n",
    "323,618\n",
    "677,562\n",
    "12\n",
    "Long sword\n",
    "382,846\n",
    "833,132\n",
    "13\n",
    "Mask\n",
    "44,676\n",
    "99,192\n",
    "14\n",
    "Necklace\n",
    "169,738\n",
    "376,418\n",
    "15\n",
    "Opal badge\n",
    "610,876\n",
    "1,253,986\n",
    "16\n",
    "Pearls\n",
    "854,190\n",
    "1,853,562\n",
    "17\n",
    "Quiver\n",
    "671,123\n",
    "1,320,297\n",
    "18\n",
    "Ruby ring\n",
    "698,180\n",
    "1,301,637\n",
    "19\n",
    "Silver bracelet\n",
    "446,517\n",
    "859,835\n",
    "20\n",
    "Timepiece\n",
    "909,620\n",
    "1,677,534\n",
    "21\n",
    "Uniform\n",
    "904,818\n",
    "1,910,501\n",
    "22\n",
    "Venom potion\n",
    "730,061\n",
    "1,528,646\n",
    "23\n",
    "Wool scarf\n",
    "931,932\n",
    "1,827,477\n",
    "24\n",
    "Crossbow\n",
    "952,360\n",
    "2,068,204\n",
    "25\n",
    "Yesteryear book\n",
    "926,023\n",
    "1,746,556\n",
    "26\n",
    "Zinc cup\n",
    "978,724\n",
    "2,100,851'''\n",
    "\n",
    "\n",
    "# Converting the raw data into a list and extracting items, weights & values\n",
    "large_items_data = large_items_data.split('\\n')\n",
    "\n",
    "l_items = [large_items_data[i] for i in range(1,len(large_items_data),4)]\n",
    "l_weights = [int(large_items_data[i].replace(',','')) for i in range(2,len(large_items_data),4)]\n",
    "l_values = [int(large_items_data[i].replace(',','')) for i in range(3,len(large_items_data),4)]\n",
    "\n",
    "# Creating an items list with the following format for each entry---> (item, weight, value)\n",
    "large_items_list = list(zip(l_items,l_weights,l_values))\n",
    "\n",
    "# Packaging the list with other parameters\n",
    "l_max_weight = 6_404_180 # Maximum weight allowed for the knapsack\n",
    "l_optimal_value = 13_692_887 # Value for the optimal solution\n",
    "large_items_package = large_items_list, l_max_weight, l_optimal_value\n",
    "\n",
    "# Viewing the contents of the large items list\n",
    "for item in large_items_list:\n",
    "    print(f\"{item[0]:<20}weight:{item[1]:<8}   value:{item[2]}$\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "307154ee",
   "metadata": {},
   "source": [
    "## II. Brute-force approach to the \"Knapsack problem\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b5792cf3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 67,108,863/67,108,863 (100.00%)\n",
      "\n",
      "Best solution:\n",
      "*Emerald belt\n",
      "*Fossil\n",
      "*Helmet\n",
      "*Knife\n",
      "*Long sword\n",
      "*Necklace\n",
      "*Pearls\n",
      "*Uniform\n",
      "*Venom potion\n",
      "*Crossbow\n",
      "*Zinc cup\n",
      "\n",
      "===>Best solution value: 13,692,887\n",
      "\n",
      "===>True optimal solution (13,692,887) was discovered\n",
      "\n",
      "Total iterations: 67,108,863\n",
      "Total time taken: 163.42 seconds (2.72 minutes)\n"
     ]
    }
   ],
   "source": [
    "# ==================================================== #\n",
    "# ==============BRUTE FORCE APPROACH================== #\n",
    "# ==================================================== #\n",
    "\n",
    "# Importing the necessary libraries\n",
    "import itertools\n",
    "import time\n",
    "\n",
    "\n",
    "# Defining functions for main()\n",
    "def get_weight(combo):\n",
    "    '''Returns the associated weight of a combination'''\n",
    "    return sum(item[1] for item in combo)\n",
    "\n",
    "\n",
    "def get_value(combo):\n",
    "    '''Returns the associated weight of a combination'''\n",
    "    return sum(item[2] for item in combo)\n",
    "\n",
    "\n",
    "def print_stats(best_solution, optimal_value, computations, total_time):\n",
    "    '''Print the results and brief evaluation statistics for the search'''\n",
    "\n",
    "    print(\"\\nBest solution:\")\n",
    "    for item in best_solution:\n",
    "        print(f\"*{item[0].capitalize()}\")\n",
    "        \n",
    "    print(f\"\\n===>Best solution value: {get_value(best_solution):,}\")\n",
    "    if get_value(best_solution) == optimal_value:\n",
    "        print(f\"\\n===>True optimal solution ({optimal_value:,}) was discovered\")\n",
    "    \n",
    "    print(f\"\\nTotal iterations: {computations:,}\")\n",
    "    print(f\"Total time taken: {total_time:.2f} seconds ({total_time/60:.2f} minutes)\")\n",
    "    \n",
    "    \n",
    "def main ():\n",
    "    # Defining global variables\n",
    "    global computations\n",
    "    global best_solution\n",
    "    \n",
    "    # Timing counter for evaluating performance\n",
    "    start_time = time.perf_counter()\n",
    "\n",
    "    # Generating combinations in the range: 1-->n (where n= no. available items)\n",
    "    for i in range(1,len(chosen_item_list)+1):\n",
    "        for combo in  itertools.combinations(chosen_item_list,i):\n",
    "            computations += 1\n",
    "            # Printing iterations in multiples of 50,000 for larger calculations\n",
    "            if computations % 50_000 == 0:\n",
    "                print(f\"Iteration: {computations:>{pad},}/{max_iterations:,} ({computations/max_iterations*100:.2f}%)\", end='\\r')\n",
    "\n",
    "            # Getting the weight and value of the current combination\n",
    "            current_weight = get_weight(combo)\n",
    "            current_value = get_value(combo)\n",
    "\n",
    "            # Setting/updating the best solution based the value of the current combination\n",
    "            if (current_weight <= max_weight) and (current_value > get_value(best_solution)):\n",
    "                best_solution = combo\n",
    "                continue\n",
    "\n",
    "    # Printing the final iteration log\n",
    "    print(f\"Iteration: {computations:>{pad},}/{max_iterations:,} ({computations/max_iterations*100:.2f}%)\")\n",
    "\n",
    "    # Calculating the total time elapsed\n",
    "    end_time = time.perf_counter()\n",
    "    total_time = end_time - start_time\n",
    "\n",
    "    # Print a brief report for the search\n",
    "    print_stats(best_solution, optimal_value, computations, total_time)\n",
    "\n",
    "# ================================================================== #\n",
    "# ================================================================== #\n",
    "\n",
    "# Choose the item package for the search\n",
    "chosen_item_list, max_weight, optimal_value = large_items_package\n",
    "\n",
    "# Set globals for the brute force search\n",
    "best_solution = (('dummy', 0, 0),)\n",
    "computations = 0\n",
    "max_iterations = 2**(len(chosen_item_list)) - 1\n",
    "pad = len(f\"{max_iterations:,}\")\n",
    "\n",
    "# ================================================================== #\n",
    "# ================================================================== #\n",
    "\n",
    "# Running main() if executed directly\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4535e60",
   "metadata": {},
   "source": [
    "## III. Evolutionary algorithm based search for the \"Knapsack problem\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "819b16cb",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generation #45\n",
      "Best solution:\n",
      "*Emerald belt\n",
      "*Fossil\n",
      "*Helmet\n",
      "*Knife\n",
      "*Long sword\n",
      "*Necklace\n",
      "*Pearls\n",
      "*Uniform\n",
      "*Venom potion\n",
      "*Crossbow\n",
      "*Zinc cup\n",
      "\n",
      "===>Best solution value: 13,692,887\n",
      "\n",
      "****SEARCH SUCCESSFUL***\n",
      "True optimal solution (13,692,887) was discovered\n",
      "\n",
      "Total no. of generations: 45\n",
      "Total time taken: 0.19 seconds (0.00 minutes)\n",
      "\n",
      "Please specify the type of result to display:\n",
      "*Type '1' for value increase per generation\n",
      "*Type '2' for encoding scheme per generation\n",
      "1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ==================================================== #\n",
    "# =========EVOLUTIONARY ALGORITHM APPROACH============ #\n",
    "# ==================================================== #\n",
    "\n",
    "# Importing the necessary libraries\n",
    "import random\n",
    "import time\n",
    "\n",
    "\n",
    "# Defining functions for main()\n",
    "def get_weight(individual):\n",
    "    '''Returns the associated weight of an individual'''\n",
    "    return sum(chosen_item_list[i][1] for i in range(len(individual)) if individual[i] == 1)\n",
    "\n",
    "\n",
    "def get_value(individual):\n",
    "    '''Returns the associated value of an individual'''\n",
    "    return sum(chosen_item_list[i][2] for i in range(len(individual)) if individual[i] == 1)\n",
    "\n",
    "\n",
    "def initialize_parents(parents_for_next_generation, max_weight):\n",
    "    '''Returns a list of valid, randomly generated individuals (parents) for the 1st run of the algorithm'''\n",
    "    all_parents = []\n",
    "    for x in range(parents_for_next_generation):\n",
    "        while True:\n",
    "            parent = [random.randint(0,1) for x in range(len(chosen_item_list))]\n",
    "            weight = get_weight(parent)\n",
    "            if weight <= max_weight: # Accepting an individual if it satisfies the max weight criterion\n",
    "                all_parents.append(parent)\n",
    "                break\n",
    "    return all_parents\n",
    "\n",
    "\n",
    "def generate_child(*parents, mutation_rate=0.5):\n",
    "    '''Return a child from a supplied population of parents via random recombination.\n",
    "    Supports single point random mutations based on a mutation rate (default=0.5)'''\n",
    "    child = [random.choice(parents)[x] for x in range(len(parents[0]))]\n",
    "    if random.random() < mutation_rate:\n",
    "        change_index = random.randint(0, len(child)-1)\n",
    "        child[change_index] = 0 if child[change_index] == 1 else 1\n",
    "    return child\n",
    "\n",
    "    \n",
    "def get_items(individual):\n",
    "    '''Returns a list of items included in an individual'''\n",
    "    return [chosen_item_list[i][0] for i in range(len(individual)) if individual[i] == 1]\n",
    "\n",
    "\n",
    "def solution_found(current_value, optimal_value):\n",
    "    '''Returns True is the optimal solution has been found'''\n",
    "    if current_value == optimal_value:\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "\n",
    "def print_stats(best_individual, optimal_value, current_generation, total_time):\n",
    "    '''Print the results and brief evaluation statistics for the search'''\n",
    "    \n",
    "    print(\"\\nBest solution:\")\n",
    "    for item in get_items(best_individual):\n",
    "        print(f\"*{item}\")\n",
    "    print(f\"\\n===>Best solution value: {get_value(best_individual):,}\")\n",
    "\n",
    "    if best_individual_value == optimal_value:\n",
    "        print(f\"\\n****SEARCH SUCCESSFUL***\\nTrue optimal solution ({optimal_value:,}) was discovered\")\n",
    "    else:\n",
    "        print(f\"\\n****SEARCH FAILED****\\nTrue optimal solution ({optimal_value:,}) was NOT discovered\")\n",
    "    print(f\"\\nTotal no. of generations: {current_generation+1}\")\n",
    "    print(f\"Total time taken: {total_time:.2f} seconds ({total_time/60:.2f} minutes)\")\n",
    "\n",
    "\n",
    "def plot_search_progress(data, total_generations=None, type='value_per_gen'):\n",
    "    '''Plot the progression of the search\n",
    "    type could be either \"value_per_gen\" or \"one_hot_encoding\" '''\n",
    "    import matplotlib.pyplot as plt\n",
    "    import numpy as np\n",
    "    \n",
    "    _data = data.copy() # Copying data to avoid side-effects\n",
    "    \n",
    "    if type == 'value_per_gen':\n",
    "        plt.style.use('seaborn-darkgrid')\n",
    "        fig, ax = plt.subplots(figsize=(8,4),dpi=200)\n",
    "        ax.plot([x[0] for x in _data], [x[1] for x in _data], label='Best individual value')\n",
    "        ax.axhline(optimal_value, c='red', lw=2, label='Optimal value')\n",
    "        ax.legend(frameon=True, facecolor='white', shadow=True)\n",
    "        ax.set_xlabel(\"Generations\")\n",
    "        ax.set_ylabel(\"Value (individual fitness)\")\n",
    "        ax.set_title(\"Evolutionary algorithm based optimation of the Knapsack problem\", pad=20)\n",
    "    \n",
    "    elif type == 'one_hot_encoding':\n",
    "        _data.append(np.zeros(26)) # Using a numpy array to avoid a ragged array \n",
    "        _data.append([3 if x == 1 else 0 for x in _data[-2]])\n",
    "        plt.style.use('seaborn-dark')\n",
    "        fig, ax = plt.subplots(figsize=(8,8), dpi=200)\n",
    "        ax.imshow(_data, cmap=plt.get_cmap('Blues'))\n",
    "        ax.set_ylabel(\"Generations\", fontsize=9)\n",
    "        ax.set_xlabel(\"One-hot encoding scheme\", fontsize=9)\n",
    "        ax.set_xticklabels([])\n",
    "        plt.yticks(fontsize=8)\n",
    "        for x in range(0, len(_data)-2):\n",
    "            ax.axhline(x, c='white', lw=1, alpha=0.5)\n",
    "        \n",
    "    \n",
    "    \n",
    "def main(*,print_report=True, plot_results=True, return_gen=False):\n",
    "    # Defining global variables\n",
    "    global best_individual_value\n",
    "    \n",
    "    # Timing counter for evaluating performance\n",
    "    start_time = time.perf_counter()\n",
    "    \n",
    "    # Intializing initial parents\n",
    "    all_parents = initialize_parents(parents_for_next_generation, max_weight)\n",
    "    \n",
    "    # Generating lists for logging best individual values for each generation\n",
    "    best_individual_value_per_generation = []\n",
    "    best_individual_per_generation = []\n",
    "    \n",
    "    # Running the evolutionary algorithm for the specified generations\n",
    "    for current_generation in range(generations):\n",
    "        # Printing the current generation number\n",
    "        if print_report:\n",
    "            print(f\"Generation #{current_generation+1}\", end='\\r')\n",
    "        \n",
    "        # Checking if the optimal solution has been found\n",
    "        if solution_found(best_individual_value, optimal_value):\n",
    "            break\n",
    "\n",
    "        # Including all initial parents as individuals of the current generation\n",
    "        children = all_parents.copy()\n",
    "\n",
    "        # Generating children for the current generation\n",
    "        for j in range(progeny_per_generation):\n",
    "            child = generate_child(*all_parents, mutation_rate=mutation_rate)\n",
    "            child_weight = get_weight(child)\n",
    "\n",
    "            # Rejecting a child if it violates the max weight criterion\n",
    "            if child_weight > max_weight:\n",
    "                continue\n",
    "            else:\n",
    "                children.append(child)\n",
    "\n",
    "        # Iterating over the individuals of the current generation\n",
    "        for child in children:\n",
    "            # Setting/updating the best solution based on the child's value\n",
    "            child_value = get_value(child)\n",
    "            if child_value > best_individual_value:\n",
    "                best_individual = child\n",
    "                best_individual_value = child_value\n",
    "\n",
    "        # Selecting the best individuals from the current as parents for the next generation\n",
    "        all_parents = sorted(children, key=get_value, reverse=True)[:parents_for_next_generation]\n",
    "        \n",
    "        # Logging the generation and the best individual's value\n",
    "        best_individual_value_per_generation.append((current_generation+1, get_value(all_parents[0])))\n",
    "        best_individual_per_generation.append(all_parents[0])\n",
    "\n",
    "    # Calculating the total time elapsed\n",
    "    end_time = time.perf_counter()\n",
    "    total_time = end_time - start_time\n",
    "    \n",
    "    # Print a report for the search\n",
    "    if print_report:\n",
    "        print_stats(best_individual,optimal_value,current_generation,total_time)\n",
    "    \n",
    "    # Plotting the best value per generation\n",
    "    if plot_results:\n",
    "        type_of_plot = int(input(\"\\nPlease specify the type of result to display:\\n*Type '1' for value increase per generation\\n*Type '2' for encoding scheme per generation\\n\").strip())\n",
    "        if type_of_plot == 1:\n",
    "            plot_search_progress(best_individual_value_per_generation, type='value_per_gen')\n",
    "        elif type_of_plot == 2:\n",
    "            plot_search_progress(best_individual_per_generation, type='one_hot_encoding')\n",
    "        \n",
    "    # Return the final generation if asked\n",
    "    if return_gen:\n",
    "        return current_generation+1\n",
    "    \n",
    "    # Returning True is search was successful\n",
    "    if best_individual_value == optimal_value:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "# ================================================================== #\n",
    "# ================================================================== #\n",
    "\n",
    "# Choose the item package for the search\n",
    "chosen_item_list, max_weight, optimal_value = large_items_package\n",
    "\n",
    "# Set globals and hyperparameters for the evolutionary algorithm\n",
    "best_individual = None\n",
    "best_individual_value = 0\n",
    "generations = 1000\n",
    "progeny_per_generation = 250\n",
    "parents_for_next_generation = 100\n",
    "mutation_rate = 1\n",
    "\n",
    "# ================================================================== #\n",
    "# ================================================================== #\n",
    "\n",
    "# Running main() if executed directly\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7d04cd0",
   "metadata": {},
   "source": [
    "## IV. Testing the accuracy and success rate of the evolutionary algorithm based search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "173363e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Search #100:\tSUCCESSFUL   \n",
      "Total success rate: 98/100 (98.00%)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1500x1200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Calculating the average success rate of the search\n",
    "import matplotlib.pyplot as plt\n",
    "number_of_searches = 100\n",
    "successes = 0\n",
    "\n",
    "# Choose the item package for the testing phase\n",
    "chosen_item_list, max_weight, optimal_value = large_items_package\n",
    "\n",
    "# Lists for capturing plotting variables\n",
    "gen_numbers = []\n",
    "failures = []\n",
    "\n",
    "# Testing the algorithms iteratively\n",
    "for i in range(number_of_searches):\n",
    "    # Set globals and hyperparameters for the evolutionary algorithm\n",
    "    best_individual = None\n",
    "    best_individual_value = 0\n",
    "    generations = 100\n",
    "    progeny_per_generation = 500\n",
    "    parents_for_next_generation = 250\n",
    "    mutation_rate = 1\n",
    "    \n",
    "    # Using the 'return_gen' parameter to obtain generation values\n",
    "    gen_num = main(print_report=False, plot_results=False, return_gen=True)\n",
    "    \n",
    "    # Appening the generations to the 'gen_numbers' list if the algorithm ended before max generations was reached\n",
    "    if gen_num != generations:\n",
    "        gen_numbers.append(gen_num)\n",
    "        failures.append(i)\n",
    "        successes += 1\n",
    "        print(f\"Search #{i+1}:\\tSUCCESSFUL\", end='\\r')\n",
    "    else: # Reaching max gen denotes a failure\n",
    "        gen_numbers.append(0)\n",
    "        failures.append(-1)\n",
    "        print(f\"Search #{i+1}:\\tFAILED        \", end='\\r')\n",
    "        \n",
    "# Printing the total success rate\n",
    "print(f\"\\nTotal success rate: {successes}/{number_of_searches} ({successes/number_of_searches*100:.2f}%)\")\n",
    "\n",
    "# Generating x and y axes for plotting\n",
    "xs = [x for x in range(len(gen_numbers))]\n",
    "failed_gens = [-1 if x==0 else 0 for x in gen_numbers]\n",
    "\n",
    "# Plotting the testing phase as a bar chart\n",
    "plt.style.use(\"seaborn-darkgrid\")\n",
    "fig, ax = plt.subplots(figsize=(10,8), dpi=150)\n",
    "ax.bar(xs,gen_numbers, label=f'Successful tests ({successes/number_of_searches*100:.2f}%)')\n",
    "ax.bar(xs, failed_gens, color='red', label=f'Failed tests ({100 - (successes/number_of_searches*100):.2f}%)')\n",
    "\n",
    "# Setting plot labels and legend\n",
    "ax.set_title(f\"Testing the evolutionary algorithm\\n(Max generations={generations}, Recombining individuals={parents_for_next_generation},\\nProgeny stength={progeny_per_generation}, Random mutation rate={mutation_rate})\")\n",
    "ax.set_ylabel(\"Generations created for optimal solution discovery\")\n",
    "ax.set_xlabel(\"Testing cycles\", labelpad=10)\n",
    "ax.legend(frameon=True, facecolor='white', shadow=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d263d76",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}