EDL_5_5_ES_HPO.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "EDL_5_5_ES_HPO.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyPC40DDSDZGyWX8xTQtIz2e",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "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_5_5_ES_HPO.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7eo9h5KA5UPe"
      },
      "source": [
        "# Setup"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jpHn_-RfV0_n",
        "outputId": "612686e1-1c0f-4f8d-fcbe-e4370ae394fd"
      },
      "source": [
        "#@title Install DEAP\n",
        "!pip install deap --quiet"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[?25l\r\u001b[K     |██                              | 10kB 26.5MB/s eta 0:00:01\r\u001b[K     |████▏                           | 20kB 32.0MB/s eta 0:00:01\r\u001b[K     |██████▏                         | 30kB 21.8MB/s eta 0:00:01\r\u001b[K     |████████▎                       | 40kB 17.1MB/s eta 0:00:01\r\u001b[K     |██████████▍                     | 51kB 15.7MB/s eta 0:00:01\r\u001b[K     |████████████▍                   | 61kB 17.4MB/s eta 0:00:01\r\u001b[K     |██████████████▌                 | 71kB 13.6MB/s eta 0:00:01\r\u001b[K     |████████████████▋               | 81kB 14.2MB/s eta 0:00:01\r\u001b[K     |██████████████████▋             | 92kB 13.3MB/s eta 0:00:01\r\u001b[K     |████████████████████▊           | 102kB 12.6MB/s eta 0:00:01\r\u001b[K     |██████████████████████▉         | 112kB 12.6MB/s eta 0:00:01\r\u001b[K     |████████████████████████▉       | 122kB 12.6MB/s eta 0:00:01\r\u001b[K     |███████████████████████████     | 133kB 12.6MB/s eta 0:00:01\r\u001b[K     |█████████████████████████████   | 143kB 12.6MB/s eta 0:00:01\r\u001b[K     |███████████████████████████████ | 153kB 12.6MB/s eta 0:00:01\r\u001b[K     |████████████████████████████████| 163kB 12.6MB/s \n",
            "\u001b[?25h"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FslekLiVp_Il"
      },
      "source": [
        "#@title Defining Imports\n",
        "#numpy\n",
        "import numpy as np\n",
        "#DEAP\n",
        "from deap import algorithms\n",
        "from deap import base\n",
        "from deap import benchmarks\n",
        "from deap import creator\n",
        "from deap import tools\n",
        "#PyTorch\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch.autograd import Variable\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import TensorDataset, DataLoader\n",
        "#plotting\n",
        "from matplotlib import pyplot as plt\n",
        "from matplotlib import cm\n",
        "from IPython.display import clear_output\n",
        "#utils\n",
        "import random\n",
        "import math\n",
        "import array\n",
        "import time"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "MQCdK2oWJlid",
        "outputId": "3aba8520-63b3-4e48-aff4-8db524bd2c59"
      },
      "source": [
        "#@title Setup Target Function and Data\n",
        "def function(x):\n",
        "  return (2*x + 3*x**2 + 4*x**3 + 5*x**4 + 6*x**5 + 10) \n",
        "\n",
        "data_min = -5\n",
        "data_max = 5\n",
        "data_step = .5\n",
        "Xi = np.reshape(np.arange(data_min, data_max, data_step), (-1, 1))\n",
        "yi = function(Xi)\n",
        "inputs = Xi.shape[1]\n",
        "yi = yi.reshape(-1, 1)\n",
        "plt.plot(Xi, yi, 'o', color='black')\n",
        "plt.plot(Xi,yi, color=\"red\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7fd15646f090>]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eY30bijNqNBL"
      },
      "source": [
        "#@title Define the Model\n",
        "class Net(nn.Module):\n",
        "  def __init__(self, inputs, middle):\n",
        "    super().__init__()\n",
        "    self.fc1 = nn.Linear(inputs,middle)    \n",
        "    self.fc2 = nn.Linear(middle,middle)    \n",
        "    self.out = nn.Linear(middle,1)\n",
        "  def forward(self, x):\n",
        "    x = F.relu(self.fc1(x))     \n",
        "    x = F.relu(self.fc2(x))    \n",
        "    x = self.out(x)\n",
        "    return x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nsBRAusqy7Uz"
      },
      "source": [
        "#@title Define HyperparametersEC Class\n",
        "class HyperparametersEC(object):\n",
        "  def __init__(self, **kwargs):\n",
        "    self.__dict__.update(kwargs) \n",
        "    self.hparms = [d for d in self.__dict__]  \n",
        "        \n",
        "  def __str__(self):\n",
        "    out = \"\"\n",
        "    for d in self.hparms:\n",
        "      ds = self.__dict__[d]\n",
        "      out += f\"{d} = {ds} \"\n",
        "    return out   \n",
        "\n",
        "  def values(self):\n",
        "    vals = []\n",
        "    for d in self.hparms:\n",
        "      vals.append(self.__dict__[d])\n",
        "    return vals\n",
        "\n",
        "  def size(self):\n",
        "    return len(self.hparms)\n",
        "\n",
        "  def next(self, individual):\n",
        "    dict = {}\n",
        "    #initialize generators\n",
        "    for i, d in enumerate(self.hparms):\n",
        "      next(self.__dict__[d])\n",
        "    for i, d in enumerate(self.hparms):      \n",
        "      dict[d] = self.__dict__[d].send(individual[i])\n",
        "    return HyperparametersEC(**dict)   \n",
        "\n",
        "def clamp(num, min_value, max_value):\n",
        "   return max(min(num, max_value), min_value)\n",
        "\n",
        "def linespace(min,max):\n",
        "  rnge = max - min\n",
        "  while True:\n",
        "    i = yield\n",
        "    i = (clamp(i, -1.0, 1.0) + 1.0) / 2.0\n",
        "    yield i * rnge + min\n",
        "\n",
        "def linespace_int(min,max):\n",
        "  rnge = max - min\n",
        "  while True:\n",
        "    i = yield\n",
        "    i = (clamp(i, -1.0, 1.0) + 1.0) / 2.0\n",
        "    yield int(i * rnge) + min\n",
        "\n",
        "def static(val):\n",
        "  while True:\n",
        "    yield val"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Y9-31iHVPqm"
      },
      "source": [
        "# Create the HyperparamtersEC Object"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ciFUE2XDzhMk",
        "outputId": "ef9183d2-c2cb-453b-ecfb-abb73eaf9a74"
      },
      "source": [
        "#@title Instantiate the HPO\n",
        "hp = HyperparametersEC(\n",
        "  middle_layer = linespace_int(8, 64),\n",
        "  learning_rate = linespace(3.5e-02,3.5e-01),\n",
        "  batch_size = static(16),    \n",
        "  epochs = static(200)  \n",
        ")\n",
        "\n",
        "ind = [-.5, .75, -.1, .8]\n",
        "print(hp.next(ind))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "middle_layer = 22 learning_rate = 0.31062499999999993 batch_size = 16 epochs = 200 \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SNgP_WM4VakF",
        "outputId": "6fc4b9dd-2736-4146-9cc9-ce5d0e7a1a1d"
      },
      "source": [
        "cuda = True if torch.cuda.is_available() else False\n",
        "print(\"Using CUDA\" if cuda else \"Not using CUDA\")\n",
        "Tensor = torch.cuda.FloatTensor if cuda else torch.Tensor"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Using CUDA\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SiomzsQfWoL5"
      },
      "source": [
        "# Setup DEAP for ES Search"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yTrNof0Cub4F"
      },
      "source": [
        "#@title ES Bounding Hyperparameters\n",
        "IND_SIZE = hp.size()\n",
        "NGEN = 10\n",
        "MIN_VALUE = -1\n",
        "MAX_VALUE = 1\n",
        "MIN_STRATEGY = 0.5\n",
        "MAX_STRATEGY = 5\n",
        "\n",
        "CXPB = .6\n",
        "MUTPB = .3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j6sqsbkKWmw_"
      },
      "source": [
        "#@title Create the Creator\n",
        "creator.create(\"FitnessMin\", base.Fitness, weights=(-1.0,))\n",
        "creator.create(\"Individual\", array.array, typecode=\"d\", fitness=creator.FitnessMin, strategy=None)\n",
        "creator.create(\"Strategy\", array.array, typecode=\"d\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sYdKKbkzZnvC"
      },
      "source": [
        "#@title Individual generator and decorate functions\n",
        "def generateES(icls, scls, size, imin, imax, smin, smax):  \n",
        "  ind = icls(random.uniform(imin, imax) for _ in range(size))  \n",
        "  ind.strategy = scls(random.uniform(smin, smax) for _ in range(size))  \n",
        "  return ind\n",
        "\n",
        "def checkStrategy(minstrategy):\n",
        "  def decorator(func):\n",
        "    def wrappper(*args, **kargs):\n",
        "      children = func(*args, **kargs)\n",
        "      for child in children:\n",
        "        for i, s in enumerate(child.strategy):\n",
        "          if s < minstrategy:\n",
        "            child.strategy[i] = minstrategy\n",
        "      return children\n",
        "    return wrappper\n",
        "  return decorator"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J161LLLguzUf"
      },
      "source": [
        "#@title Setup the Toolbox\n",
        "toolbox = base.Toolbox()\n",
        "toolbox.register(\"individual\", generateES, creator.Individual, creator.Strategy,\n",
        "    IND_SIZE, MIN_VALUE, MAX_VALUE, MIN_STRATEGY, MAX_STRATEGY)\n",
        "toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)\n",
        "toolbox.register(\"mate\", tools.cxESBlend, alpha=0.25)\n",
        "toolbox.register(\"mutate\", tools.mutESLogNormal, c=1.0, indpb=0.06)\n",
        "toolbox.register(\"select\", tools.selTournament, tournsize=3)\n",
        "\n",
        "toolbox.decorate(\"mate\", checkStrategy(MIN_STRATEGY))\n",
        "toolbox.decorate(\"mutate\", checkStrategy(MIN_STRATEGY))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zCbrGhsr6IhK"
      },
      "source": [
        "# Create a Training Function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 293
        },
        "id": "je4Jf9Vp88Rq",
        "outputId": "9f47b96b-151d-4500-9a52-eb091ec73536"
      },
      "source": [
        "#@title Wrapper Function for DL\n",
        "loss_fn = nn.MSELoss()\n",
        "if cuda:\n",
        "  loss_fn.cuda()\n",
        "\n",
        "def train_function(hp): \n",
        "  X = np.reshape(\n",
        "      np.arange(\n",
        "          data_min, \n",
        "          data_max, \n",
        "          data_step)\n",
        "      , (-1, 1))\n",
        "  y = function(X)\n",
        "  inputs = X.shape[1]\n",
        "  \n",
        "  tensor_x = torch.Tensor(X) # transform to torch tensor\n",
        "  tensor_y = torch.Tensor(y)\n",
        "  \n",
        "  dataset = TensorDataset(tensor_x,tensor_y) # create your datset\n",
        "  dataloader = DataLoader(dataset, batch_size= hp.batch_size, shuffle=True) # create your dataloader\n",
        "\n",
        "  model = Net(inputs, hp.middle_layer)  \n",
        "  optimizer = optim.Adam(model.parameters(), lr=hp.learning_rate)\n",
        "  if cuda:\n",
        "    model.cuda()    \n",
        "  \n",
        "  history=[]  \n",
        "  start = time.time()\n",
        "  for i in range(hp.epochs):        \n",
        "    for X, y in iter(dataloader):\n",
        "      # wrap the data in variables\n",
        "      x_batch = Variable(torch.Tensor(X).type(Tensor))\n",
        "      y_batch = Variable(torch.Tensor(y).type(Tensor))                   \n",
        "      # forward pass\n",
        "      y_pred = model(x_batch)        \n",
        "      # compute and print loss\n",
        "      loss = loss_fn(y_pred, y_batch)  \n",
        "      ll = loss.data\n",
        "      history.append(ll)                   \n",
        "      # reset gradients\n",
        "      optimizer.zero_grad()        \n",
        "      # backwards pass\n",
        "      loss.backward()        \n",
        "      # step the optimizer - update the weights\n",
        "      optimizer.step()  \n",
        "  end = time.time() - start\n",
        "  return end, history, model, hp\n",
        "\n",
        "hp_in = hp.next(ind)\n",
        "span, history, model, hp_out = train_function(hp_in)\n",
        "plt.plot(history)\n",
        "print(min(history).item())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "355.89935302734375\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NRQ0U-6UaUlJ"
      },
      "source": [
        "# ES Evaluate Function in Toolbox"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SfgZvw9haOQX"
      },
      "source": [
        "#@title Create Evaluation Function and Register\n",
        "run_history = []\n",
        "\n",
        "def evaluate(individual):\n",
        "  hp_in = hp.next(individual)\n",
        "  span, history, model, hp_out = train_function(hp_in)\n",
        "  y_ = model(torch.Tensor(Xi).type(Tensor))  \n",
        "  fitness = loss_fn(y_, torch.Tensor(yi).type(Tensor)).data.item()  \n",
        "  run_history.append([fitness,*hp_out.values()]) \n",
        "  return fitness, \n",
        "\n",
        "# fitness eval\n",
        "toolbox.register(\"evaluate\", evaluate)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8-M8o_OJVjg5"
      },
      "source": [
        "# Perform the HPO"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 457
        },
        "id": "xxp8Ir2kvQ6N",
        "outputId": "59fe4437-e760-4235-de85-480deb760675"
      },
      "source": [
        "random.seed(64)\n",
        "    \n",
        "MU, LAMBDA = 10, 25\n",
        "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",
        "best = None\n",
        "best_hp = None\n",
        "\n",
        "start = time.time()\n",
        "for g in range(NGEN):\n",
        "  pop, logbook = algorithms.eaMuCommaLambda(pop, toolbox, mu=MU, lambda_=LAMBDA, \n",
        "            cxpb=CXPB, mutpb=MUTPB, ngen=1, stats=stats, halloffame=hof, verbose=False)\n",
        "  best = hof[0]\n",
        "\n",
        "  span, history, model, hp_out = train_function(hp.next(best))\n",
        "  y_ = model(torch.Tensor(Xi).type(Tensor))  \n",
        "  fitness = loss_fn(y_, torch.Tensor(yi).type(Tensor)).data.item()     \n",
        "  run_history.append([fitness,*hp_out.values()]) \n",
        "  best_hp = hp_out\n",
        "\n",
        "  clear_output()    \n",
        "  fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18,6))    \n",
        "  fig.suptitle(f\"Best Fitness {best.fitness} \\n{best_hp}\")\n",
        "  fig.text(0,0,f\"Generation {g+1}/{NGEN} Current Fitness {fitness} \\n{hp_out}\")\n",
        "  ax1.plot(history)\n",
        "  ax1.set_xlabel(\"iteration\") \n",
        "  ax1.set_ylabel(\"loss\")\n",
        "\n",
        "  ax2.plot(Xi, yi, 'o', color='black') \n",
        "  ax2.plot(Xi,y_.detach().cpu().numpy(), 'r') \n",
        "  ax2.set_xlabel(\"X\") \n",
        "  ax2.set_ylabel(\"Y\")\n",
        "  \n",
        "  rh = np.array(run_history)      \n",
        "  hexbins = ax3.hexbin(rh[:, 1], rh[:, 2], C=rh[:, 0], \n",
        "                        bins=50, gridsize=25+g, cmap=cm.get_cmap('gray'))\n",
        "  ax3.set_xlabel(\"middle_layer\")\n",
        "  ax3.set_ylabel(\"learning_rate\")    \n",
        "      \n",
        "  plt.show()\n",
        "  time.sleep(1)\n",
        "\n",
        "\n",
        "     "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1296x432 with 3 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}