EDL_5_6_DE_HPO_PCA.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "EDL_5_6_DE_HPO_PCA.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyPIzROg9puiXPNxOH82mivk",
      "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_6_DE_HPO_PCA.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": "6d1c9add-57b2-4534-b2a9-1d83bedd616e"
      },
      "source": [
        "#@title Install DEAP\n",
        "!pip install deap --quiet"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[?25l\r\u001b[K     |██                              | 10 kB 23.6 MB/s eta 0:00:01\r\u001b[K     |████                            | 20 kB 17.3 MB/s eta 0:00:01\r\u001b[K     |██████                          | 30 kB 14.5 MB/s eta 0:00:01\r\u001b[K     |████████▏                       | 40 kB 13.1 MB/s eta 0:00:01\r\u001b[K     |██████████▏                     | 51 kB 6.7 MB/s eta 0:00:01\r\u001b[K     |████████████▏                   | 61 kB 7.6 MB/s eta 0:00:01\r\u001b[K     |██████████████▎                 | 71 kB 6.6 MB/s eta 0:00:01\r\u001b[K     |████████████████▎               | 81 kB 7.3 MB/s eta 0:00:01\r\u001b[K     |██████████████████▎             | 92 kB 7.5 MB/s eta 0:00:01\r\u001b[K     |████████████████████▍           | 102 kB 6.9 MB/s eta 0:00:01\r\u001b[K     |██████████████████████▍         | 112 kB 6.9 MB/s eta 0:00:01\r\u001b[K     |████████████████████████▍       | 122 kB 6.9 MB/s eta 0:00:01\r\u001b[K     |██████████████████████████▌     | 133 kB 6.9 MB/s eta 0:00:01\r\u001b[K     |████████████████████████████▌   | 143 kB 6.9 MB/s eta 0:00:01\r\u001b[K     |██████████████████████████████▌ | 153 kB 6.9 MB/s eta 0:00:01\r\u001b[K     |████████████████████████████████| 160 kB 6.9 MB/s \n",
            "\u001b[?25h"
          ]
        }
      ]
    },
    {
      "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",
        "#SkLearn\n",
        "from sklearn.decomposition import PCA\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": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "MQCdK2oWJlid",
        "outputId": "5c4e4205-b003-44da-e276-4a3915c95e27"
      },
      "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": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7fce8d95ce90>]"
            ]
          },
          "metadata": {},
          "execution_count": 3
        },
        {
          "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": "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": 4,
      "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": 5,
      "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": "4205d718-4d78-41fa-d00e-d5110bba3214"
      },
      "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 = linespace_int(4,20),    \n",
        "  epochs = linespace_int(50,400)  \n",
        ")\n",
        "\n",
        "ind = [-.5, -.3, -.1, .8]\n",
        "print(hp.next(ind))"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "middle_layer = 22 learning_rate = 0.14525 batch_size = 11 epochs = 365 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ubSMH-0uhuCO",
        "outputId": "7ab72f17-98b6-4f0e-be4e-9ce8bb1d550a"
      },
      "source": [
        "#@title Check for Cuda/GPU\n",
        "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": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using CUDA\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 276
        },
        "id": "PXPpiBDyTRXh",
        "outputId": "9ac10459-70a6-40c2-f167-e54b11c80f31"
      },
      "source": [
        "#@title Setup Principle Component Analysis\n",
        "#create example individuals\n",
        "pop = np.array([[-.5, .75, -.1, .8], [-.5, -.3, -.5, .8]])\n",
        "pca = PCA(n_components=2)\n",
        "reduced = pca.fit_transform(pop)\n",
        "\n",
        "t = reduced.transpose()\n",
        "\n",
        "plt.scatter(t[0], t[1])\n",
        "plt.show()"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "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": "markdown",
      "metadata": {
        "id": "SiomzsQfWoL5"
      },
      "source": [
        "[link text](https://)# Setup DEAP for DE Search"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yTrNof0Cub4F"
      },
      "source": [
        "#@title DE Bounding Hyperparameters\n",
        "NDIM = hp.size()\n",
        "CR = 0.25\n",
        "F_ = 1  \n",
        "MU = 50\n",
        "NGEN = 10  "
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j6sqsbkKWmw_"
      },
      "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": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J161LLLguzUf"
      },
      "source": [
        "#@title Add Genetic Operators to Toolbox\n",
        "toolbox = base.Toolbox()\n",
        "toolbox.register(\"attr_float\", random.uniform, -1, 1)\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": 11,
      "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": "e9f5ef99-040b-42e0-e107-b88994b78b26"
      },
      "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": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1690.660400390625\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"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NRQ0U-6UaUlJ"
      },
      "source": [
        "# DE 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": 13,
      "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": "213ae8bb-2e4e-4f59-f728-a6666a81a5b7"
      },
      "source": [
        "random.seed(64)\n",
        "    \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",
        "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",
        "  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",
        "  M = rh[:,1:NDIM+1]      \n",
        "  reduced = pca.fit_transform(M)\n",
        "  t = reduced.transpose() \n",
        "  hexbins = ax3.hexbin(t[0], t[1], C=rh[:, 0], \n",
        "                        bins=50, gridsize=50, cmap=cm.get_cmap('gray'))\n",
        "  ax3.set_xlabel(\"PCA X\")\n",
        "  ax3.set_ylabel(\"PCA Y\")    \n",
        "      \n",
        "  plt.show()\n",
        "  time.sleep(1)  "
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1296x432 with 3 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}