EDL_4_5_DE.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "EDL_4_5_DE.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyP9q7sBp+RujdCQEqX+RaFG",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/cxbxmxcx/EvolutionaryDeepLearning/blob/main/EDL_4_5_DE.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZWk8QVItlplD"
      },
      "source": [
        "Original Source: https://github.com/DEAP/deap/blob/master/examples/ga/onemax_numpy.py\n",
        "\n",
        "DEAP is free software: you can redistribute it and/or modify\n",
        "   it under the terms of the GNU Lesser General Public License as\n",
        "   published by the Free Software Foundation, either version 3 of\n",
        "   the License, or (at your option) any later version.\n",
        "\n",
        "   DEAP is distributed in the hope that it will be useful,\n",
        "   but WITHOUT ANY WARRANTY; without even the implied warranty of\n",
        "   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n",
        "   GNU Lesser General Public License for more details.\n",
        "   You should have received a copy of the GNU Lesser General Public\n",
        "   License along with DEAP. If not, see <http://www.gnu.org/licenses/>."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ct-pwA_aHMMa"
      },
      "source": [
        "#@title Install DEAP\n",
        "!pip install deap --quiet"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "epVL5qPDHCPW"
      },
      "source": [
        "#@title Imports\n",
        "import random\n",
        "import array\n",
        "import time\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "from deap import base\n",
        "from deap import benchmarks\n",
        "from deap import creator\n",
        "from deap import tools\n",
        "\n",
        "%matplotlib inline\n",
        "import matplotlib.pyplot as plt\n",
        "from IPython.display import clear_output"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m9M4DgcgK3Tr"
      },
      "source": [
        "#@title Hyperparameters\n",
        "NDIM = 6\n",
        "CR = 0.25\n",
        "F = 1  \n",
        "MU = 300\n",
        "NGEN = 1000  \n",
        "GEN_OUTPUT = 25\n",
        "MAX_TIME = 5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s3r8TiOjHYyy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "34a5aae1-67a6-4c1c-fa5b-56cc8dd6fe6f"
      },
      "source": [
        "#@title Setup Fitness Criteria\n",
        "creator.create(\"FitnessMin\", base.Fitness, weights=(-1.0,))\n",
        "creator.create(\"Individual\", array.array, typecode='d', fitness=creator.FitnessMin)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/deap/creator.py:141: RuntimeWarning: A class named 'FitnessMin' has already been created and it will be overwritten. Consider deleting previous creation of that class or rename it.\n",
            "  RuntimeWarning)\n",
            "/usr/local/lib/python3.7/dist-packages/deap/creator.py:141: RuntimeWarning: A class named 'Individual' has already been created and it will be overwritten. Consider deleting previous creation of that class or rename it.\n",
            "  RuntimeWarning)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DP0BRxxAH1uh"
      },
      "source": [
        "#@title Add Genetic Operators to Toolbox\n",
        "toolbox = base.Toolbox()\n",
        "toolbox.register(\"attr_float\", random.uniform, -3, 3)\n",
        "toolbox.register(\"individual\", tools.initRepeat, creator.Individual, toolbox.attr_float, NDIM)\n",
        "toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)\n",
        "toolbox.register(\"select\", tools.selRandom, k=3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "OWfZMKx3MAcX",
        "outputId": "2b065362-246d-4347-e6cf-2e23ebdc2234"
      },
      "source": [
        "#@title Generate regression data\n",
        "equation_form = \"polynomial\" #@param [\"polynomial\", \"abs\", \"step\"]\n",
        "\n",
        "X_START = -5\n",
        "X_END = 5\n",
        "X_STEP = 0.5\n",
        "\n",
        "def equation(x):\n",
        "  if equation_form == \"polynomial\":\n",
        "    return (2*x + 3*x**2 + 4*x**3 + 5*x**4 + 6*x**5 + 10) \n",
        "  elif equation_form == \"abs\":    \n",
        "    return abs(x)\n",
        "  else:    \n",
        "    return np.where(x>1, 1, 0)     \n",
        "\n",
        "X = np.array([x for x in np.arange(X_START, X_END, X_STEP)])\n",
        "Y = equation(X)\n",
        "data = list(zip(X, Y))\n",
        "\n",
        "plt.scatter(X,Y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.collections.PathCollection at 0x7f61fea97e90>"
            ]
          },
          "metadata": {},
          "execution_count": 16
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-RS30hHBKe9L"
      },
      "source": [
        "import csv\n",
        "with open('data.csv', 'w') as f:      \n",
        "    # using csv.writer method from CSV package\n",
        "    write = csv.writer(f)      \n",
        "    write.writerows(data)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UM87TusHv8ab"
      },
      "source": [
        "#@title Evaluation of fitness\n",
        "def pred(ind, x):    \n",
        "  y_ = 0.0    \n",
        "  for i in range(1,NDIM):\n",
        "    y_ += ind[i-1]*x**i    \n",
        "  y_ += ind[NDIM-1]       \n",
        "  return y_\n",
        "\n",
        "def fitness(ind, data):    \n",
        "  mse = 0.0    \n",
        "  for x, y in data:        \n",
        "    y_ = pred(ind, x)\n",
        "    mse += (y - y_)**2        \n",
        "  return mse/len(data),\n",
        "\n",
        "# fitness eval\n",
        "toolbox.register(\"evaluate\", fitness, data=data)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FUWLROMvM1z6"
      },
      "source": [
        "#@title Plot Fitness\n",
        "def plot_fitness(g, best, pop, logbook):\n",
        "  Y_ = np.array([pred(best, x) for x in X])\n",
        "  clear_output()\n",
        "  print(f\"Generation {g}, Best {best}\") \n",
        "  print(logbook.stream)\n",
        "  fits = [f.fitness.values[0] for f in pop]  \n",
        "  plt.hist(fits)\n",
        "  plt.show()\n",
        "  plt.scatter(X,Y)\n",
        "  plt.plot(X,Y_, 'r')\n",
        "  plt.show()   "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 976
        },
        "id": "QvsWliTQiI7j",
        "outputId": "d5e054b5-8b5c-44b9-b423-7f1b0b20bb52"
      },
      "source": [
        "pop = toolbox.population(n=MU);\n",
        "hof = tools.HallOfFame(1)\n",
        "stats = tools.Statistics(lambda ind: ind.fitness.values)\n",
        "stats.register(\"avg\", np.mean)\n",
        "stats.register(\"std\", np.std)\n",
        "stats.register(\"min\", np.min)\n",
        "stats.register(\"max\", np.max)\n",
        "\n",
        "logbook = tools.Logbook()\n",
        "logbook.header = \"gen\", \"evals\", \"std\", \"min\", \"avg\", \"max\"\n",
        "\n",
        "# Evaluate the individuals\n",
        "fitnesses = toolbox.map(toolbox.evaluate, pop)\n",
        "for ind, fit in zip(pop, fitnesses):\n",
        "    ind.fitness.values = fit\n",
        "\n",
        "record = stats.compile(pop)\n",
        "logbook.record(gen=0, evals=len(pop), **record)\n",
        "print(logbook.stream)\n",
        "start = time.time()\n",
        "for g in range(1, NGEN):\n",
        "  for k, agent in enumerate(pop):\n",
        "    a,b,c = toolbox.select(pop)\n",
        "    y = toolbox.clone(agent)\n",
        "    index = random.randrange(NDIM)\n",
        "    for i, value in enumerate(agent):\n",
        "      if i == index or random.random() < CR:\n",
        "        y[i] = a[i] + F*(b[i]-c[i])\n",
        "    y.fitness.values = toolbox.evaluate(y)\n",
        "    if y.fitness > agent.fitness:\n",
        "      pop[k] = y            \n",
        "  hof.update(pop)    \n",
        "  record = stats.compile(pop)\n",
        "  logbook.record(gen=g, evals=len(pop), **record)\n",
        "  if (g+1) % GEN_OUTPUT == 0:\n",
        "    plot_fitness(g, hof[0], pop, logbook) \n",
        "    end = time.time()\n",
        "    if end-start > MAX_TIME:\n",
        "      break\n",
        "\n",
        "print(\"Best individual is \", hof[0], hof[0].fitness.values[0])\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Generation 99, Best Individual('d', [-24.18388320965048, 4.8931361748926, 5.1003703100526625, 4.861666935729579, 6.011428837784546, 17.883332602151455])\n",
            "75 \t300  \t57191.6    \t3511.87    \t64019.1    \t371679     \n",
            "76 \t300  \t54117.7    \t3511.87    \t62788.7    \t333256     \n",
            "77 \t300  \t52388.4    \t3511.87    \t60881.9    \t333256     \n",
            "78 \t300  \t52254.3    \t2283.67    \t60019.6    \t333256     \n",
            "79 \t300  \t51927.6    \t2283.67    \t59269.3    \t333256     \n",
            "80 \t300  \t50880.9    \t2283.67    \t57744.1    \t333256     \n",
            "81 \t300  \t50189.1    \t2283.67    \t56880.5    \t321940     \n",
            "82 \t300  \t50208.9    \t2283.67    \t56401.3    \t321940     \n",
            "83 \t300  \t48781.9    \t2283.67    \t55801      \t321940     \n",
            "84 \t300  \t48328.4    \t2283.67    \t55385.7    \t321940     \n",
            "85 \t300  \t47929.8    \t2283.67    \t54873.3    \t321940     \n",
            "86 \t300  \t47387.4    \t2283.67    \t54216      \t321940     \n",
            "87 \t300  \t47438.2    \t1409.41    \t53883.6    \t321940     \n",
            "88 \t300  \t47121.1    \t1409.41    \t53009.4    \t321940     \n",
            "89 \t300  \t46953      \t1409.41    \t52693.4    \t321940     \n",
            "90 \t300  \t46760      \t1409.41    \t52026.5    \t321940     \n",
            "91 \t300  \t46744.7    \t1409.41    \t51711.4    \t321940     \n",
            "92 \t300  \t46636.2    \t1409.41    \t51288.2    \t321940     \n",
            "93 \t300  \t43969.5    \t1409.41    \t49946.1    \t321940     \n",
            "94 \t300  \t42215.8    \t1409.41    \t48648.1    \t321940     \n",
            "95 \t300  \t41171      \t1409.41    \t47893.7    \t321940     \n",
            "96 \t300  \t37516.9    \t1409.41    \t46432.4    \t221968     \n",
            "97 \t300  \t37305.7    \t1409.41    \t46016.1    \t221968     \n",
            "98 \t300  \t37069.5    \t1409.41    \t45280.9    \t221968     \n",
            "99 \t300  \t37055.7    \t1409.41    \t45108.4    \t221968     \n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best individual is  Individual('d', [-24.18388320965048, 4.8931361748926, 5.1003703100526625, 4.861666935729579, 6.011428837784546, 17.883332602151455]) 1409.412359942684\n"
          ]
        }
      ]
    }
  ]
}