OneMax.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# OneMax Problem\n",
      "The problem is very simple, we search for a 1 filled solution. This notebook will cover creating a program to evolve a solution to this problem as well as go a little more in detail on the step of the algorithm.\n",
      "\n",
      "## Imports\n",
      "We first get the required modules for our evolution.\n",
      "\n",
      "- `random` gives us a way to generate random bits;\n",
      "- `base` gives us access to the Toolbox and base Fitness;\n",
      "- `creator` allows us to create our types;\n",
      "- `tools` grants us access to the operators bank;\n",
      "- `algorithms` enables us some ready generic evolutionary loops."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import random\n",
      "from deap import base, creator, tools, algorithms"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Type Creation\n",
      "First step with DEAP is to create the required types. Usually the types created are the fitness and the individual. For the OneMax problem, we want to have a solution with as many ones as possible. Thus we need a maximizing fitness and a individual that is a sorted container, we'll choose the standard `list`.\n",
      "\n",
      "Type creation is done by calling the function `create` in the creator module. This function takes two mandatory arguments and additional optional arguments. The first argument is the actual name of the type that we want to create. The second argument is the base classe that the new type created should inherit from. Finally, the optional arguments are members to add to the new type."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "creator.create(\"FitnessMax\", base.Fitness, weights=(1.0,))\n",
      "creator.create(\"Individual\", list, fitness=creator.FitnessMax)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 13
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The first line creates a maximizing fitness by replacing, in the base type Fitness, the pure virtual weights attribute by (1.0,) that means to maximize a single objective fitness. The second line creates an Individual class that inherits the properties of list and has a fitness attribute of the type FitnessMax that was just created.\n",
      "\n",
      "Single objective is considered by DEAP the same way a multi objective function would but with a single value. The weights (as well as the returned value from the evaluation) are **always required** to be iterable.\n",
      "\n",
      "The created classes are made available in the creator module. We can instantiate directly objects of the created class like follow. This step is not required in an algorithm, the instatiation will be automated later."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ind = creator.Individual([1, 0, 1, 1, 0])\n",
      "\n",
      "print(ind)\n",
      "print(type(ind))\n",
      "print(type(ind.fitness))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 0, 1, 1, 0]\n",
        "<class 'deap.creator.Individual'>\n",
        "<class 'deap.creator.FitnessMax'>\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Toolbox\n",
      "The toolbox is intended to store functions with their arguments under standard aliases for uses in algorithms. Functions are registered by a function call with two mandatory arguments, the alias to give to the function and the function it will be associate with. Any additional argument will be given as argument when the alias is called."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "toolbox = base.Toolbox()\n",
      "toolbox.register(\"attr_bool\", random.randint, 0, 1)\n",
      "toolbox.register(\"individual\", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=10)\n",
      "toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In the last block of code we created a toolbox object and registered three functions. This first one, `attr_bool`, calls randint from the random module with arguments (0, 1) to create an integer in the interval $[0, 1]$. The second function, `individual`, when called, will use the initRepeat function made available in the tools module to fill an `Individual` class with what is produced by 10 calls to the previously defined `attr_bool` function. The same thing is done for the `population` function.\n",
      "\n",
      "For example, calling every function individually shows how it proceeds."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "bit = toolbox.attr_bool()\n",
      "ind = toolbox.individual()\n",
      "pop = toolbox.population(n=3)\n",
      "\n",
      "print(\"bit is of type %s and has value\\n%s\" % (type(bit), bit))\n",
      "print(\"ind is of type %s and contains %d bits\\n%s\" % (type(ind), len(ind), ind))\n",
      "print(\"pop is of type %s and contains %d individuals\\n%s\" % (type(pop), len(pop), pop))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "bit is of type <type 'int'> and has value\n",
        "0\n",
        "ind is of type <class 'deap.creator.Individual'> and contains 10 bits\n",
        "[0, 0, 0, 0, 0, 0, 0, 1, 0, 0]\n",
        "pop is of type <type 'list'> and contains 3 individuals\n",
        "[[1, 1, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [1, 0, 0, 1, 0, 1, 1, 0, 0, 1]]\n"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Evaluation Function\n",
      "The evaluation function is pretty simple for the OneMax problem, we need to count the number of ones in an individual. We recall here that the returned value must be an iterable of length equal to the number of objectives (weights)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def evalOneMax(individual):\n",
      "    return sum(individual),"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 17
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Genetic Operators\n",
      "Registering the operators and their default arguments in the toolbox is done as follow."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "toolbox.register(\"evaluate\", evalOneMax)\n",
      "toolbox.register(\"mate\", tools.cxTwoPoint)\n",
      "toolbox.register(\"mutate\", tools.mutFlipBit, indpb=0.10)\n",
      "toolbox.register(\"select\", tools.selTournament, tournsize=3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 18
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The evaluation is given the alias `evaluate`. Having a single argument being the individual to evaluate we don\u2019t need to fix any, the individual will be given later in the algorithm. The two points crossover function is registered the same way under the alias `mate`. The mutation, for its part, needs an argument to be fixed (the independent probability of each attribute to be mutated `indpb`). In the algorithms the `mutate()` function is called with the signature `toolbox.mutate(mutant)`. This is the most convenient way because each mutation takes a different number of arguments, having those arguments fixed in the toolbox leave open most of the possibilities to change the mutation (crossover, selection, or evaluation) operator later in your researches. Finally, the selection operator is registered under the name `select` and the size of the tournament set to 3.\n",
      "\n",
      "We can for example mutate an individual and expect 10% of its attributes to be flipped."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ind = toolbox.individual()\n",
      "print(ind)\n",
      "toolbox.mutate(ind)\n",
      "print(ind)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0, 1, 1, 1, 0, 0, 1, 0, 0, 1]\n",
        "[0, 1, 1, 1, 0, 0, 0, 0, 0, 1]\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The operators execute their behaviour on the individuals in place, meaning that if the individual is not copied before modified the old individual is lost. Copying an individual is done with the `clone` function available in every toolbox."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "mutant = toolbox.clone(ind)\n",
      "print(mutant is ind)\n",
      "print(mutant == ind)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "False\n",
        "True\n"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Evolving the Population\n",
      "The main program shall be defined in a main function. All previous declarations are put in the global scope of the module to make created objects available for further use in other user experiments.\n",
      "\n",
      "The main program is very simple. It consists of generating a population, and giving it to the algorithm for it to evolve a solution. Here we will employ some helpful introspection tools such as Statistics and a Hall of Fame. The statistics are computed using `numpy` functions on the population, and the hall of fame keeps track of the best individuals that ever appeared during the evolution. The algorithm take as arguments, among other, the population and the toolbox. Once the evolution is finished the population contains the individuals from the last generation."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def main():\n",
      "    import numpy\n",
      "    \n",
      "    pop = toolbox.population(n=50)\n",
      "    hof = tools.HallOfFame(1)\n",
      "    stats = tools.Statistics(lambda ind: ind.fitness.values)\n",
      "    stats.register(\"avg\", numpy.mean)\n",
      "    stats.register(\"min\", numpy.min)\n",
      "    stats.register(\"max\", numpy.max)\n",
      "    \n",
      "    pop, logbook = algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=0.2, ngen=10, stats=stats, halloffame=hof, verbose=True)\n",
      "    \n",
      "    return pop, logbook, hof"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 21
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Next, we protect our call to the main function and launch the evolution, the verbose argument tell to output the stats on every generations. We can print and plot the data returned. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if __name__ == \"__main__\":\n",
      "    pop, log, hof = main()\n",
      "    print(\"Best individual is: %s\\nwith fitness: %s\" % (hof[0], hof[0].fitness))\n",
      "    \n",
      "    import matplotlib.pyplot as plt\n",
      "    gen, avg, min_, max_ = log.select(\"gen\", \"avg\", \"min\", \"max\")\n",
      "    plt.plot(gen, avg, label=\"average\")\n",
      "    plt.plot(gen, min_, label=\"minimum\")\n",
      "    plt.plot(gen, max_, label=\"maximum\")\n",
      "    plt.xlabel(\"Generation\")\n",
      "    plt.ylabel(\"Fitness\")\n",
      "    plt.legend(loc=\"lower right\")\n",
      "    plt.show()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "gen\tnevals\tavg\tmin\tmax\n",
        "0  \t50    \t5  \t1  \t8  \n",
        "1  \t26    \t6.14\t3  \t8  \n",
        "2  \t33    \t7.16\t5  \t9  \n",
        "3  \t39    \t7.88\t6  \t10 \n",
        "4  \t37    \t8.4 \t6  \t10 \n",
        "5  \t31    \t8.9 \t6  \t10 "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "6  \t30    \t9.28\t7  \t10 \n",
        "7  \t27    \t9.58\t7  \t10 \n",
        "8  \t30    \t9.74\t7  \t10 \n",
        "9  \t27    \t9.86\t9  \t10 "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "10 \t31    \t9.72\t8  \t10 \n",
        "Best individual is: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]\n",
        "with fitness: (10.0,)\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "display_data",
       "png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEKCAYAAAAVaT4rAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIYQwMpL4hRDCyEjiF0III/N/vALe4Mjf4GoAAAAASUVORK5CYII=\n",
       "text": [
        "<matplotlib.figure.Figure at 0x112e3e250>"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 22
    }
   ],
   "metadata": {}
  }
 ]
}