examples/Simple EA.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple EA\n",
    "\n",
    "In this example, you will be introduced to the main components of the EvolvePy package.\n",
    "\n",
    "- Defining a fitness function\n",
    "- Using evaluators\n",
    "- Using generators\n",
    "- Evolving a population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import evolvepy as ep\n",
    "\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generator\n",
    "\n",
    "The first main component, generator, allow the generation of populations according to the evaluations of individuals, using evolutionary operators such as crossover and mutation.\n",
    "\n",
    "Let's define a simple generator with tournament selection, one point crossover and mutation. We use layers to represent each operator that will be executed on the population, sequentially."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from evolvepy.generator import Generator, CombineLayer\n",
    "from evolvepy.generator.descriptor import Descriptor\n",
    "from evolvepy.generator.mutation import NumericMutationLayer, sum_mutation\n",
    "from evolvepy.generator.crossover import one_point\n",
    "from evolvepy.generator.selection import tournament\n",
    "\n",
    "# Defines the layers of the generator\n",
    "layers = [CombineLayer(tournament, one_point), NumericMutationLayer(sum_mutation, 1.0, 0.0, (-10.0, 10.0))]\n",
    "\n",
    "# Specify that an individual has only one chromosome, which can vary between -1000 and 4000 \n",
    "descriptor = Descriptor(1, (-1000.0, 4000.0), [np.float32])\n",
    "\n",
    "# Creates the generator\n",
    "generator = Generator(layers=layers, descriptor=descriptor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's generate some example individuals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "generator.generate(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the array type is some strange `[('chr0', '<f4', (1,))]` type. It is because EvolvePy uses NumPy structured arrays to represent individuals, allowing individuals to have different chromosomes of different sizes and types. We'll explore this in later examples, where we'll define different operators for each chromosome.\n",
    "\n",
    "`[('chr0', '<f4', (1,))]` means that an individual has an entry, called \"chr0\" (as if it were an element of a structure in C/C++), of type \"<f4\", which represents float32, and each chromosome has only one gene."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fitness function and evaluators\n",
    "\n",
    "The fitness function is the function that will assess whether our population is evolving in the direction we want. We will use here a simple unidimensional function to examplify."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fitness_function(individuals):\n",
    "    # Gets the first gene of chromosome \"chr0\" (default name), in the first and only individual\n",
    "    individual = individuals[0][\"chr0\"][0] \n",
    "\n",
    "    score = 0\n",
    "\n",
    "    if individual < 500:\n",
    "        score = individual\n",
    "    elif individual < 1000:\n",
    "        score = 1000 - individual\n",
    "    elif individual < 2000:\n",
    "        score = individual - 1000\n",
    "    else:\n",
    "        score = 3000 - individual\n",
    "\n",
    "    return score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have the function, but we also need some way to evaluate all the population using it. Here enters the evaluators. With them, we can define different ways to evaluate our individuals. Let's start with FunctionEvaluator, a simple evaluator that just takes one function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from evolvepy.evaluator import FunctionEvaluator\n",
    "\n",
    "evaluator = FunctionEvaluator(fitness_function)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can create a simple population and evaluate it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "population = generator.generate(100)\n",
    "\n",
    "fitness = evaluator(population)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(population, fitness, \"o\")\n",
    "plt.xlabel(\"Individual\")\n",
    "plt.ylabel(\"Fitness\")\n",
    "plt.title(\"Fitness sample\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Fitness Sample](Simple_EA-Figure1.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evolver\n",
    "\n",
    "The last presented component, Evolver uses the generator and evaluator to optimize the population in relation to the fitness function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from evolvepy import Evolver\n",
    "\n",
    "# Here we specify for Evolver to use the previously created generator and evaluator, in generations of 100 individuals.\n",
    "evolver = Evolver(generator, evaluator, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can finally optimize the population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Optmizes over 200 generations\n",
    "hist, last_population = evolver.evolve(200) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(hist.max(axis=1))\n",
    "plt.plot(hist.mean(axis=1))\n",
    "\n",
    "plt.legend([\"Best\", \"Mean\"])\n",
    "plt.ylabel(\"Fitness\")\n",
    "\n",
    "plt.ylim(800,1100)\n",
    "plt.title(\"Evolution history\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observes how the algorithm fast find the best possible individual. In more complex problems, this process can take several generations, and we may not be sure that the algorithm has come to an end.\n",
    "\n",
    "(OBS: due to the randomness of the algorithm, the example graph below and the one generated above may be different)\n",
    "\n",
    "![Evolution history](Simple_EA-Figure2.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another important thing to notice is the decline in best fitness in the early generations. That's because we don't define any form of elitism for our algorithm. Let's do that next."
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "2db524e06e9f5f4ffedc911c917cb75e12dbc923643829bf417064a77eb14d37"
  },
  "kernelspec": {
   "display_name": "Python 3.8.5 64-bit",
   "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.8.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}