EDL_5_4_PSO_HPO_PCA.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "EDL_5_4_PSO_HPO_PCA.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyP7A5P3txqPT7iAJbVkat4d",
      "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_4_PSO_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": "426a271c-c9ff-4a65-8d50-c7dd16d323b4"
      },
      "source": [
        "#@title Install DEAP\n",
        "!pip install deap --quiet"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[?25l\r\u001b[K     |██                              | 10 kB 36.3 MB/s eta 0:00:01\r\u001b[K     |████                            | 20 kB 39.9 MB/s eta 0:00:01\r\u001b[K     |██████                          | 30 kB 42.3 MB/s eta 0:00:01\r\u001b[K     |████████▏                       | 40 kB 27.1 MB/s eta 0:00:01\r\u001b[K     |██████████▏                     | 51 kB 19.2 MB/s eta 0:00:01\r\u001b[K     |████████████▏                   | 61 kB 15.3 MB/s eta 0:00:01\r\u001b[K     |██████████████▎                 | 71 kB 14.6 MB/s eta 0:00:01\r\u001b[K     |████████████████▎               | 81 kB 16.1 MB/s eta 0:00:01\r\u001b[K     |██████████████████▎             | 92 kB 17.6 MB/s eta 0:00:01\r\u001b[K     |████████████████████▍           | 102 kB 13.7 MB/s eta 0:00:01\r\u001b[K     |██████████████████████▍         | 112 kB 13.7 MB/s eta 0:00:01\r\u001b[K     |████████████████████████▍       | 122 kB 13.7 MB/s eta 0:00:01\r\u001b[K     |██████████████████████████▌     | 133 kB 13.7 MB/s eta 0:00:01\r\u001b[K     |████████████████████████████▌   | 143 kB 13.7 MB/s eta 0:00:01\r\u001b[K     |██████████████████████████████▌ | 153 kB 13.7 MB/s eta 0:00:01\r\u001b[K     |████████████████████████████████| 160 kB 13.7 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 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",
        "#for performance timing\n",
        "import time\n",
        "#utils\n",
        "import random\n",
        "import math"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 286
        },
        "id": "MQCdK2oWJlid",
        "outputId": "88d384ed-b22a-4c56-ca99-a2c1e321e9e2"
      },
      "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 0x7f2ddf1cffd0>]"
            ]
          },
          "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": 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\n"
      ],
      "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": "ca886ca7-bbbc-46cd-bab0-ee3af699e855"
      },
      "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": null,
      "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/",
          "height": 276
        },
        "id": "an3L3f6_62E3",
        "outputId": "5af1b546-afca-4987-a43d-b50c0d35601f"
      },
      "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": null,
      "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": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WlIWCGtB1vSx",
        "outputId": "413faf4f-973d-4f0b-85ff-e5d1bd55cf20"
      },
      "source": [
        "#@title Setup CUDA for use with 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": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using CUDA\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SiomzsQfWoL5"
      },
      "source": [
        "# Setup DEAP for PSO Search"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j6sqsbkKWmw_"
      },
      "source": [
        "#@title Setup Fitness Criteria\n",
        "creator.create(\"FitnessMax\", base.Fitness, weights=(1.0,))\n",
        "creator.create(\"Particle\", np.ndarray, fitness=creator.FitnessMax, speed=list, \n",
        "    smin=None, smax=None, best=None)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sYdKKbkzZnvC"
      },
      "source": [
        "#@title PSO Functions\n",
        "def generate(size, pmin, pmax, smin, smax):\n",
        "  part = creator.Particle(np.random.uniform(pmin, pmax, size)) \n",
        "  part.speed = np.random.uniform(smin, smax, size)\n",
        "  part.smin = smin\n",
        "  part.smax = smax\n",
        "  return part\n",
        "\n",
        "def updateParticle(part, best, phi1, phi2):\n",
        "  u1 = np.random.uniform(0, phi1, len(part))\n",
        "  u2 = np.random.uniform(0, phi2, len(part))\n",
        "  v_u1 = u1 * (part.best - part)\n",
        "  v_u2 = u2 * (best - part)\n",
        "  part.speed += v_u1 + v_u2\n",
        "  for i, speed in enumerate(part.speed):\n",
        "    if abs(speed) < part.smin:\n",
        "      part.speed[i] = math.copysign(part.smin, speed)\n",
        "    elif abs(speed) > part.smax:\n",
        "      part.speed[i] = math.copysign(part.smax, speed)\n",
        "  part += part.speed"
      ],
      "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": 310
        },
        "id": "je4Jf9Vp88Rq",
        "outputId": "d4dc55e0-9dfa-43c1-b7aa-c4ab716cb5e3"
      },
      "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",
        "print(hp_in)\n",
        "plt.plot(history)\n",
        "print(min(history).item())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "middle_layer = 22 learning_rate = 0.14525 batch_size = 11 epochs = 365 \n",
            "2386.06689453125\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": [
        "# DEAP Toolbox"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SfgZvw9haOQX"
      },
      "source": [
        "#@title Create Evaluation Function and Register\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",
        "  return fitness, \n",
        "\n",
        "#@title Add Functions to Toolbox\n",
        "toolbox = base.Toolbox()\n",
        "toolbox.register(\"particle\", \n",
        "                 generate, size=hp.size(), pmin=-.25, pmax=.25, smin=-.25, smax=.25)\n",
        "toolbox.register(\"population\", \n",
        "                 tools.initRepeat, list, toolbox.particle)\n",
        "toolbox.register(\"update\", \n",
        "                 updateParticle, phi1=2, phi2=2)\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": "CfAwK51KiO1O",
        "outputId": "b6e76070-75ee-467c-ef62-68ee85c9be97"
      },
      "source": [
        "random.seed(64)\n",
        "    \n",
        "pop = toolbox.population(n=25)\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\"] + stats.fields\n",
        "\n",
        "ITS = 10\n",
        "NDIM = hp.size()\n",
        "\n",
        "best = None\n",
        "best_part = None\n",
        "best_hp = None\n",
        "run_history = []\n",
        "\n",
        "for i in range(ITS):          \n",
        "  for part in pop:       \n",
        "    part.fitness.values = toolbox.evaluate(part)  \n",
        "    hp_eval = hp.next(part)\n",
        "    run_history.append([part.fitness.values[0], *hp_eval.values()])\n",
        "    if part.best is None or part.best.fitness < part.fitness:\n",
        "      part.best = creator.Particle(part)\n",
        "      part.best.fitness.values = part.fitness.values\n",
        "    if best is None or best.fitness > part.fitness:\n",
        "      best = creator.Particle(part)\n",
        "      best.fitness.values = part.fitness.values\n",
        "      best_hp = hp.next(best)\n",
        "  for part in pop:\n",
        "    toolbox.update(part, best)\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",
        "\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\"Iteration {i+1}/{ITS} 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": null,
      "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"
          }
        }
      ]
    }
  ]
}