Bloque C - Ajuste y paquetes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Aropython_logo](./static/aeropython_name_mini.png)\n",
    "###### Carlos Dorado Cárdenas\n",
    "###### Siro Moreno Martín"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simplifica tu vida con sistemas complejos y algoritmos genéticos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parte 3 - Ajuste de algoritmos y paquetes de Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Influencia de los parámetros: bifurcaciones, cambios de fase y caos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En nuestros modelos, además de las propias variables de estudio, usaremos casi siempre varios parámetros para controlar su comprotamiento de manera fina. Normalmente, es de esperar que un cambio pequeño de un parámetro se traduzca en un cambio pequeño en el resultado, pero ¡cuidado! ¡No siempre es así!\n",
    "\n",
    "Llamamos **Bifurcación** a las situaciones en las que pequeños cambios en el valor de un parámetro afectan de manera drástica y cualitativa al comportamiento del sistema. \n",
    "\n",
    "Ejemplos: excitación de neuronas, formación de patrones, transición catastrófica de estados en un ecosistema."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Supongamos el siguiente modelo de pocas variables en tiempo continuo:\n",
    "$$\\frac{dx}{dt} = r - x^2$$\n",
    "\n",
    "Nuestro parámetro, r afecta al comportamiento del sistema de manera drástica en el entorno de r = 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def derivada(x,r):\n",
    "    return r - x **2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "r = -1 #Para r negativo, la derivada de x con t siempre es negativo.\n",
    "         #Para r positivo, aparecen puntos con derivada positiva o cero!\n",
    "x = np.linspace(-5,5,100)\n",
    "y = derivada(x, r)\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definamos ahora un modelo de tiempo discreto y pocas variables:\n",
    "$$ x_t = x_{t-1} + r - x_{t-1}^2 $$\n",
    "$$ x_0 = 0.1 $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def iteracion(x, r):\n",
    "    return x + r - x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 0.1\n",
    "r = 1.5 #Observa lo que ocurre en los alrededores de r = 1 y r = 1.5\n",
    "x_acc = [x,]\n",
    "for ii in range(30):\n",
    "    x = iteracion(x, r)\n",
    "    x_acc.append(x)\n",
    "plt.plot(x_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Analicemos más en detalle lo que pasa con los periodos de este modelo en función de r! \n",
    "\n",
    "Para ello, descartaremos los primeros 100 pasos, que consideraremos transitorios, y pintaremos los resultados posteriores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=[10,6])\n",
    "for r in np.linspace(0, 2, 200):\n",
    "    x = 0.1\n",
    "    x_acc = []\n",
    "    for ii in range(100):\n",
    "        x = iteracion(x, r)\n",
    "    for ii in range(100):\n",
    "        x = iteracion(x, r)\n",
    "        x_acc.append(x)\n",
    "    plt.plot([r,]*100,x_acc,  'b.', alpha = 0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las bifurcaciones que provoca el parámetro r se aprecian claramente, pero... ¿qué es esa zona extraña llena de puntos para r > 1.7 ?\n",
    "\n",
    "Eso... es Caos.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./imagenes/Star_of_Chaos.jpg\" width=\"250\" style=\"float: right\" />\n",
    "\n",
    "\n",
    "**CAOS**\n",
    "* Es un comporrtamiento de sistemas dinámicos no lineales que nunca decae a trayectorias estables o periódicas.\n",
    "* Tiene un aspecto aleatorio, pero proviene de sistemas completamente deterministas.\n",
    "* Posee una gran sensibilidad a las condiciones iniciales.\n",
    "* Aparece cuando el periodo de la trayectoria diverge a infinito.\n",
    "* También aparece cuando no existe ninguna trayectoria estable.\n",
    "* Es un fenómeno que aparece en la naturaleza de manera muy frecuente, así como en entornos sociales e ingenieriles.\n",
    "\n",
    "<small>*Fuente de la imagen: [sangre para el Dios de la Sangre!](http://warhammer40k.wikia.com/wiki/Chaos?file=Star_of_Chaos.jpg)*</small>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=[10,4])\n",
    "x = 0.1\n",
    "x_2 = x + 0.00000001\n",
    "r = 1.9\n",
    "x_acc = [x,]\n",
    "x_acc_2 = [x_2,]\n",
    "for ii in range(100):\n",
    "    x = iteracion(x, r)\n",
    "    x_acc.append(x)\n",
    "    x_2 = iteracion(x_2, r)\n",
    "    x_acc_2.append(x_2)\n",
    "plt.plot(x_acc)\n",
    "plt.plot(x_acc_2, 'g--')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Citando de nuevo a **Hiroki Sayama**:\n",
    "<blockquote><strong>Chaos</strong> can be understood as a dynamical process in which <strong>microscopic information</strong> hidden in the details of a system’s state is dug out and <strong>expanded</strong> to a macroscopically visible scale (stretching), while the <strong>macroscopic information</strong> visible in the current system’s state is continuously <strong>discarded</strong> (folding).\n",
    "</blockquote>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2 Cambio de fase"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pasemos a un modelo ligeramente más complicado: un autómata celular 2-D con el algoritmo de \"panico\":\n",
    "\n",
    "- Hay dos tipos de individuos: normales y en pánico.\n",
    "- Un individuo normal entrará en pánico si está rodeado de cuatro o más individuos en pánico.\n",
    "- Un individuo en pánico seguirá en pánico si está rodeado de tres o más personas en pánico. En caso contrario, se le pasará el susto y volvera al estado \"normal\".\n",
    "\n",
    "Condiciones del entrono del modelo:\n",
    "\n",
    "- Espacio 2-D cuadrado\n",
    "- Condición de contorno periódico (universo-toroide)\n",
    "- Distribución inicial aleatoria en la que cada individuo tiene una probabilidad *p* de estar en pánico.\n",
    "\n",
    "El profesor Hiroki ya nos ha regalado el código, que ejecutaremos en una terminal de Python (NO IPython!!)\n",
    "Este código se llama también \"droplet model\", debido a que se comporta de manera parecida a la condensación de gotas de agua!\n",
    "\n",
    "Observemos cómo el cambio del parámetro *p* provoca cambios radicales en el aspecto final del sistema dentro de un rango muy estrecho de valores: Esto se conoce como \"Cambio de Fase\" del sistema.\n",
    "\n",
    "Según Hiroki:\n",
    "\n",
    "<blockquote><strong> A phase transition</strong>  is a transition of <strong> macroscopic</strong>  properties of a collective system that occurs when its environmental or internal conditions are varied.\n",
    "</blockquote>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 2. Presentación de los modelos de Redes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Los modelos de redes para simular sistemas complejos son relativamente recientes, aunque se apoyan mucho en las teorías de grafos, una rama de las matemáticas muy anterior. Su popularidad como modelos de S.C. proviene principalmente de unos pocos papers de finales de los 90, que exploraban los conceptos de redes *small-world* y *scale-free networks*. Los modelos de redes son usados en biología, ecología, económicas, ingeniería, medicina y muchos otros campos. En la actualidad, su aplicación algorítmica en forma de redes neuronales se encuentra en fuerte expansión y goza de gran popularidad.\n",
    "\n",
    "* La principal ventaja de los modelos de redes frente a modelos más simples es su **flexibilidad** y su capacidad de definir modelos mucho más **detallados**. En los autómatas celulares nos encontrábamos con vecindarios rígidos y células homogéneas, pero con estos modelos podemos describir relaciones mucho más complicadas:\n",
    "    * Algunos nodos pueden tener muchas comunicaciones, otros muy pocas o incluso ninguna.\n",
    "    * Las relaciones entre nodos pueden ser no recíprocas, y contener características como \"peso relativo\", \"confianza\", etc.\n",
    "    * Las conexiones entre nodos pueden cambiar con el tiempo, o incluso aparecer nodos nuevos o destruir nodos existentes.\n",
    "* Por contra, también tendremos que tener en cuenta los siguientes inconvenientes:\n",
    "    * La cantidad de información inicial que tenemos que proporcionar al modelo es mucho mayor.\n",
    "    * La cantidad de datos que se manejan en cualquier paso también es mucho mayor, por lo que podemos caer con facilidad en algoritmos absurdamente costosos o pesados.\n",
    "    * La enorme cantidad de grados de libertad requiere de mucha planificación para conseguir un modelo real más allá de un bonito salvapantallas animado capaz de fundir procesadores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### 2.1 Terminología de teoría de grafos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Una **Red** o **Grafo** consiste en una serie de **Nodos** (o **Vértices** o **Actores**) unidos entre sí mediante **Aristas**, (o **Enlaces** o **Uniones** o **Conexiones**)\n",
    "* El nodo *j* es un **vecino** del nodo *i* si y sólo si el nodo *i* está conectado al nodo *j*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./imagenes/matriz-grafos.gif\" width=\"450\" style=\"float: right\" />\n",
    "\n",
    "* **Matriz de Adyacencias**: una matriz en la que el elemento $a_{ij}$ es 1 si el nodo *i* es vecino del nodo *j*, o cero si no.\n",
    "* **Lista de Adyacencias**: una lista  cuyo componente i-ésimo es una lista  de los vecinos del nodo *i*\n",
    "\n",
    "<small> Fuente de la imágen: [Hiroki Sayama](http://polymer.bu.edu/hes/book-sayama.pdf)</small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Grado** de un nodo: el número de aristas conectadas al nodo.\n",
    "* Grafo **Completo**: todos los nodos están conectados entre sí.\n",
    "* Grafo **Regular**: todos los nodos tienen el mismo grado.\n",
    "* Un **camino** es una sucesión de vértices tal que de cada uno de sus vértices existe una arista hacia el vértice sucesor.\n",
    "* Un **Ciclo** (o circuito) es un camino que empieza y acaba en el mismo vértice.\n",
    "\n",
    "Puedes consultar un vocabulario más amplio en [Wikipedia](https://es.wikipedia.org/wiki/Anexo:Glosario_de_teor%C3%ADa_de_grafos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Practicando Redes con NetworkX"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NetworkX es un paquete de Python que viene instalado por defecto con anaconda y sirve para manejar grafos. Usaremos Matplotlib para las expandir las representaciones gráficas cuando sea necesario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import networkx as nx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "g = nx.karate_club_graph()\n",
    "nx.draw(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "g = nx.Graph()\n",
    "g.add_node('Arkantos')\n",
    "g.add_nodes_from(['Ayax', 'Quiron', 'Amanra', 'Ulises'])\n",
    "g.add_edge('Arkantos','Ayax')\n",
    "g.add_edges_from([\n",
    "        ('Ayax','Quiron'),\n",
    "        ('Ulises','Ayax'),\n",
    "        ('Quiron','Ulises'),\n",
    "        ('Amanra','Arkantos'),\n",
    "        ('Amanra', 'Ayax'),\n",
    "        ('Juan Luis Cano', 'Absurdeces Aleatorias')\n",
    "    ])\n",
    "g.remove_edge('Ayax','Amanra')\n",
    "g.remove_node('Absurdeces Aleatorias')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nx.draw(g, with_labels=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "g.nodes()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "g.edges()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "g.node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "g.node['Juan Luis Cano']['job'] = 'Python Master'\n",
    "g.node['Arkantos']['origin'] = 'Atlantis'\n",
    "g.node['Arkantos']['age'] = '40'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "g.edge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "g.edge['Quiron']['Ayax']['Amistad'] = 'bastante'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NetworkX también admite grafos dirigidos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "g = nx.DiGraph()\n",
    "g.add_edge('yo', 'Sempai')\n",
    "g.edge ['yo'] ['Sempai'] ['Noticed'] = 'A lot! :D'\n",
    "g.edge ['Sempai'] ['yo']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nx.draw(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "g = nx.karate_club_graph()\n",
    "plt.figure(figsize=[10,10])\n",
    "plt.subplot(221)\n",
    "nx.draw_random(g)\n",
    "\n",
    "plt.subplot(222)\n",
    "nx.draw_circular(g)\n",
    "\n",
    "plt.subplot(223)\n",
    "nx.draw_spectral(g)\n",
    "\n",
    "plt.subplot(224)\n",
    "shells = [\n",
    "    [0,1,2,32,33],\n",
    "    [3,5,6,7,8,13,23,27,29,30,31],\n",
    "    [4,9,10,11,12,14,15,16,17,18,19,20,21,22,24,25,26,28]\n",
    "]\n",
    "nx.draw_shell(g, nlist = shells)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "positions = nx.spring_layout(g)\n",
    "nx.draw(g,\n",
    "       positions,\n",
    "       with_labels = True,\n",
    "       node_shape = '>',\n",
    "       node_size = [g.degree(i)*50 for i in g.nodes()],\n",
    "       edge_color = 'pink',\n",
    "       node_color = ['yellow' if i<17 else 'green' for i in g.nodes()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NetworkX también dispone de unas cuantas herramientas para crear grafos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "g = nx.complete_graph(6)\n",
    "nx.draw(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "nx.draw(nx.gnm_random_graph(10,20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nx.draw(nx.gnp_random_graph(20,0.1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nx.draw(nx.random_regular_graph(3,10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1 Tipos de modelos de redes\n",
    "\n",
    "Hiroki Sayama propone dividir los modelos en 3 tipos:\n",
    "- Dinámicas *en* redes: Ni las conexiones ni los nodos cambian con el tiempo, sólo sus propiedades.\n",
    "- Dinámicas *de* redes: La topología cambia con el tiempo, pero no las propiedades de los nodos.\n",
    "- Redes adaptativas: La geometría de la red y los valores de sus propiedades cambian a la vez de manera interrelacionada.\n",
    "\n",
    "Podemos usar PyCX para probar un ejemplo de cada tipo:\n",
    "- Dinámicas en redes: net-voter\n",
    "- Dinámicas de redes: net-small-world\n",
    "- Redes adaptativas: net-epidemics-adaptive"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Modelos basados en agentes\n",
    "\n",
    "Los modelos basados en agentes son los más generales de todos. Básicamente, el único requisito que tienen es que deben contener muchos agentes discretos. \n",
    "\n",
    "En palabras de Hiroki:\n",
    "\n",
    "<strong> Typical properties generally assumed in agents and ABMs</strong>\n",
    "\n",
    "- Agents are discrete entities.\n",
    "- Agents may have internal states.\n",
    "- Agents may be spatially localized.\n",
    "- Agents may perceive and interact with the environment.\n",
    "- Agents may behave based on predefined rules.\n",
    "- Agents may be able to learn and adapt.\n",
    "- Agents may interact with other agents.\n",
    "- ABMs often lack central supervisors/controllers.\n",
    "- ABMs may produce nontrivial “collective behavior” as a whole."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Debido a la enorme libertad que tenemos a la hora de programar estos modelos, siempre es recomendable seguir uno de estos procedimientos:\n",
    "\n",
    "1. Construir el ABM usando condiciones y definiciones derivadas de fenomenos observados empíricamente, y para poder después producir situaciones nuevas desconocidas con la simulación.\n",
    "2. Construir el ABM usando hipótesis nuevas, y comparar nuestra simulación con resultados empíricos de fenómenos observados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El profesor Sayama también recomienda seguir la siguiente línea de procesos para el diseño de nuestro modelo:\n",
    "\n",
    "**Design tasks you need to do when you implement an ABM**\n",
    "1.  Design the data structure to store the attributes of the agents.\n",
    "2.  Design the data structure to store the states of the environment.\n",
    "3.  Describe the rules for how the environment behaves on its own.\n",
    "4.  Describe the rules for how agents interact with the environment.\n",
    "5.  Describe the rules for how agents behave on their own.\n",
    "6.  Describe the rules for how agents interact with each other.\n",
    "\n",
    "Comprobemos ahora ejemplos, con PyCX o de nuestros notebooks!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Cómo usar PyCX para prototipar modelos rápidamente"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyCX es un script diseñado por Hiroki Sayama y ampliado por  Przemyslaw Szufel y Bogumil Kaminski de la Warsaw School of Economics.\n",
    "Nos permite añadir una capa de simulación y visualización a nuestro modelo de manera muy sencilla. \n",
    "\n",
    "Para usarlo, nuestro proyecto tiene que conservar la siguiente estructura:\n",
    "``` python\n",
    "import matplotlib\n",
    "matplotlib.use('qt4agg')\n",
    "import pylab as pl() \n",
    "\n",
    "# import necessary modules\n",
    "# define model parameters\n",
    "\n",
    "def initialize():\n",
    "    global # list global variables\n",
    "    # initialize system states\n",
    "    \n",
    "def observe():\n",
    "    global # list global variables\n",
    "    cla() # to clear the visualization space\n",
    "    # visualize system states\n",
    "\n",
    "def update():\n",
    "    global # list global variables\n",
    "    # update system states for one discrete time step\n",
    "\n",
    "import pycxsimulator\n",
    "pycxsimulator.GUI().start(func=[initialize, observe, update])\n",
    "```\n",
    "---\n",
    "Podemos descargar el script con numerosos ejemplos desde:\n",
    "http://pycx.sourceforge.net/WPyCX.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 6. El paquete DEAP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DEAP, Distributed Evolutionary Algorithms for Python, es un paquete muy completo que según se puede leer en [la página del proyecto](http://deap.readthedocs.io/en/master/):\n",
    "<blockquote>\n",
    "DEAP is a novel evolutionary computation framework for rapid prototyping and testing of ideas. It seeks to make algorithms explicit and data structures transparent. It works in perfect harmony with parallelisation mechanism such as multiprocessing and SCOOP. The following documentation presents the key concepts and many features to build your own evolutions.\n",
    "</blockquote>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "DEAP aún no se encuentra disponible en el canal principal de conda, por lo que lo tenemos que descargar del canal oficial de prueba: conda-forge. Para ello, simplemente abre una terminal de comandos y escribe:\n",
    "```\n",
    "conda install --channel https://conda.anaconda.org/conda-forge deap\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Probemos a ejecutar este ejemplo, disponible en su página: http://deap.readthedocs.io/en/master/examples/ga_onemax.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "from deap import base\n",
    "from deap import creator\n",
    "from deap import tools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "creator.create(\"FitnessMax\", base.Fitness, weights=(1.0,))\n",
    "creator.create(\"Individual\", list, fitness=creator.FitnessMax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "toolbox = base.Toolbox()\n",
    "# Attribute generator \n",
    "toolbox.register(\"attr_bool\", random.randint, 0, 1)\n",
    "# Structure initializers\n",
    "toolbox.register(\"individual\", tools.initRepeat, creator.Individual, \n",
    "    toolbox.attr_bool, 100)\n",
    "toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def evalOneMax(individual):\n",
    "    return sum(individual),"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "toolbox.register(\"evaluate\", evalOneMax)\n",
    "toolbox.register(\"mate\", tools.cxTwoPoint)\n",
    "toolbox.register(\"mutate\", tools.mutFlipBit, indpb=0.05)\n",
    "toolbox.register(\"select\", tools.selTournament, tournsize=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    random.seed(64)\n",
    "\n",
    "    # create an initial population of 300 individuals (where\n",
    "    # each individual is a list of integers)\n",
    "    pop = toolbox.population(n=300)\n",
    "\n",
    "    # CXPB  is the probability with which two individuals\n",
    "    #       are crossed\n",
    "    #\n",
    "    # MUTPB is the probability for mutating an individual\n",
    "    #\n",
    "    # NGEN  is the number of generations for which the\n",
    "    #       evolution runs\n",
    "    CXPB, MUTPB, NGEN = 0.5, 0.2, 40\n",
    "    \n",
    "    print(\"Start of evolution\")\n",
    "    \n",
    "    # Evaluate the entire population\n",
    "    fitnesses = list(map(toolbox.evaluate, pop))\n",
    "    for ind, fit in zip(pop, fitnesses):\n",
    "        ind.fitness.values = fit\n",
    "    \n",
    "    print(\"  Evaluated %i individuals\" % len(pop))\n",
    "    \n",
    "    # Begin the evolution\n",
    "    for g in range(NGEN):\n",
    "        print(\"-- Generation %i --\" % g)\n",
    "        \n",
    "        # Select the next generation individuals\n",
    "        offspring = toolbox.select(pop, len(pop))\n",
    "        # Clone the selected individuals\n",
    "        offspring = list(map(toolbox.clone, offspring))\n",
    "    \n",
    "        # Apply crossover and mutation on the offspring\n",
    "        for child1, child2 in zip(offspring[::2], offspring[1::2]):\n",
    "\n",
    "            # cross two individuals with probability CXPB\n",
    "            if random.random() < CXPB:\n",
    "                toolbox.mate(child1, child2)\n",
    "\n",
    "                # fitness values of the children\n",
    "                # must be recalculated later\n",
    "                del child1.fitness.values\n",
    "                del child2.fitness.values\n",
    "\n",
    "        for mutant in offspring:\n",
    "\n",
    "            # mutate an individual with probability MUTPB\n",
    "            if random.random() < MUTPB:\n",
    "                toolbox.mutate(mutant)\n",
    "                del mutant.fitness.values\n",
    "    \n",
    "        # Evaluate the individuals with an invalid fitness\n",
    "        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]\n",
    "        fitnesses = map(toolbox.evaluate, invalid_ind)\n",
    "        for ind, fit in zip(invalid_ind, fitnesses):\n",
    "            ind.fitness.values = fit\n",
    "        \n",
    "        print(\"  Evaluated %i individuals\" % len(invalid_ind))\n",
    "        \n",
    "        # The population is entirely replaced by the offspring\n",
    "        pop[:] = offspring\n",
    "        \n",
    "        # Gather all the fitnesses in one list and print the stats\n",
    "        fits = [ind.fitness.values[0] for ind in pop]\n",
    "        \n",
    "        length = len(pop)\n",
    "        mean = sum(fits) / length\n",
    "        sum2 = sum(x*x for x in fits)\n",
    "        std = abs(sum2 / length - mean**2)**0.5\n",
    "        \n",
    "        print(\"  Min %s\" % min(fits))\n",
    "        print(\"  Max %s\" % max(fits))\n",
    "        print(\"  Avg %s\" % mean)\n",
    "        print(\"  Std %s\" % std)\n",
    "    \n",
    "    print(\"-- End of (successful) evolution --\")\n",
    "    \n",
    "    best_ind = tools.selBest(pop, 1)[0]\n",
    "    print(\"Best individual is %s, %s\" % (best_ind, best_ind.fitness.values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejecución de ejemplos, preguntas..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Si te ha gustado este taller, háznoslo saber!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<a href=\"https://twitter.com/share\" class=\"twitter-share-button\" data-url=\"https://github.com/AeroPython/Taller-Algoritmos-Geneticos-PyConEs16\" data-text=\"Aprendiendo Algoritmos Genéticos y Sistemas Complejos con\" data-via=\"AeroPython\" data-size=\"large\" data-hashtags=\"PyConEs\" data-dnt=\"true\">Tweet</a>\n",
       "<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<a href=\"https://twitter.com/share\" class=\"twitter-share-button\" data-url=\"https://github.com/AeroPython/Taller-Algoritmos-Geneticos-PyConEs16\" data-text=\"Aprendiendo Algoritmos Genéticos y Sistemas Complejos con\" data-via=\"AeroPython\" data-size=\"large\" data-hashtags=\"PyConEs\" data-dnt=\"true\">Tweet</a>\n",
    "<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Siro Moreno, Aeropython, 7 de Octubre de 2016\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Source+Sans+Pro|Josefin+Sans:400,700,400italic|Ubuntu+Condensed' rel='stylesheet' type='text/css'>\n",
       "\n",
       "\n",
       "<style>\n",
       "\n",
       "#notebook_panel { /* main background */\n",
       "    background: #f7f7f7;\n",
       "}\n",
       "\n",
       "div.cell { /* set cell width */\n",
       "    width: 900px;\n",
       "}\n",
       "\n",
       "div #notebook { /* centre the content */\n",
       "    background: #fff; /* white background for content */\n",
       "    width: 950px;\n",
       "    margin: auto;\n",
       "    padding-left: 0em;\n",
       "}\n",
       "\n",
       "#notebook li { /* More space between bullet points */\n",
       "    margin-top:0.7em;\n",
       "}\n",
       "\n",
       "/* draw border around running cells */\n",
       "div.cell.border-box-sizing.code_cell.running { \n",
       "    border: 1px solid #111;\n",
       "}\n",
       "\n",
       "/* Put a solid color box around each cell and its output, visually linking them*/\n",
       "div.cell.code_cell {\n",
       "    font-family: 'Source Sans Pro', sans-serif;\n",
       "    background-color: rgb(256,256,256);\n",
       "    font-size: 110%;\n",
       "    border-radius: 0px; \n",
       "    padding: 0.5em;\n",
       "    margin-left:1em;\n",
       "    margin-top: 1em;\n",
       "}\n",
       "\n",
       "div.text_cell_render{\n",
       "    font-family: 'Josefin Sans', serif;\n",
       "    line-height: 145%;\n",
       "    font-size: 125%;\n",
       "    font-weight: 500;\n",
       "    width:750px;\n",
       "    margin-left:auto;\n",
       "    margin-right:auto;\n",
       "}\n",
       "\n",
       "\n",
       "/* Formatting for header cells */\n",
       ".text_cell_render h1, .text_cell_render h2, .text_cell_render h3,\n",
       ".text_cell_render h4, .text_cell_render h5 {\n",
       "    font-family: 'Ubuntu Condensed', sans-serif;\n",
       "}\n",
       "\n",
       ".text_cell_render h1 {    /*Use this for Title*/\n",
       "    font-weight: 500;\n",
       "    font-size: 38pt;\n",
       "    line-height: 100%;\n",
       "    color: #ffbc29;\n",
       "    text-align: center;\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.3em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h2 {    /*Use this for Subtitle*/\n",
       "    margin-top:16px;\n",
       "    font-size: 32pt;\n",
       "    font-weight: 500;\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.3em;\n",
       "    text-align: center;\n",
       "    font-style: regular;\n",
       "    color: #376a94;\n",
       "}\t\n",
       "\n",
       ".text_cell_render h3 {   /*Sections*/ \n",
       "    font-size: 30pt;\n",
       "    font-weight: 300;\n",
       "    text-align: left;\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.3em;\n",
       "    font-style: regular;\n",
       "    color:  #252525;\n",
       "}\n",
       "\n",
       ".text_cell_render h4 {    /*Subsections*/\n",
       "    font-size: 28pt;\n",
       "    font-weight: 200;\n",
       "    text-align: left;\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.3em;\n",
       "    font-style: regular;\n",
       "    color:  #376a94;\n",
       "}\n",
       "\n",
       ".text_cell_render h5 {    /*Subsubsections*/\n",
       "    font-size: 20pt;\n",
       "    font-weight: 300;\n",
       "    font-style: italic;\n",
       "    margin-bottom: .1em;\n",
       "    margin-top: 0.8em;\n",
       "    display: block;\n",
       "    color:  #ffbc29;\n",
       "}\n",
       "\n",
       ".text_cell_render h6 {    /*Author*/\n",
       "    font-family: 'Ubuntu Condensed', sans-serif;\n",
       "    font-weight: 100;\n",
       "    font-size: 14pt;\n",
       "    line-height: 100%;\n",
       "    color: #252525;\n",
       "    text-align: right;\n",
       "    margin-bottom: 1px;\n",
       "    margin-top: 3px;\n",
       "}\n",
       "\n",
       ".CodeMirror{\n",
       "        font-family: 'Duru Sans', sans-serif;\n",
       "        font-size: 100%;\n",
       "}\n",
       "\n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"],\n",
       "                           equationNumbers: { autoNumber: \"AMS\", useLabelIds: true}\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
       "                }\n",
       "        });\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Notebook style\n",
    "from IPython.core.display import HTML\n",
    "css_file = './static/style.css'\n",
    "HTML(open(css_file, \"r\").read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}