XXXXXX.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPxhkqtnmIDabfywLr9Twvm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/50-Course/swarm-optimizers/blob/main/XXXXXX.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "JNsCkwwgVZdv"
      },
      "outputs": [],
      "source": [
        "# DEPENDENCIES\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from fractions import Fraction\n",
        "import math"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# FUNCTION IMPLEMENTATIONS\n",
        "\n",
        "# Arguments:\n",
        "# x: A numpy array (decision vector) containing the following variables:\n",
        "#     x[0]: The tensile space.\n",
        "#     x[1]: The oil pressure.\n",
        "#     x[2]: The oil temperature rise.\n",
        "#     x[3]: The oil film thickness.\n",
        "#     x[4]: The step radius.\n",
        "#     x[5]: The recess radius.\n",
        "#     x[6]: The viscosity of the oil.\n",
        "#     x[7]: The contact pressure.\n",
        "\n",
        "def P(x):\n",
        "  return (np.log10(np.log10(8.122 * x[3] + 0.8)) - 10.04) / -3.55\n",
        "\n",
        "def W(x):\n",
        "  \"\"\"Calculates the load carrying capacity.\n",
        "\n",
        "  Args:\n",
        "    x: A\n",
        "      x[0]: The inlet pressure.\n",
        "      x[1]: The outlet pressure.\n",
        "      x[2]: The oil thickness.\n",
        "      x[3]: The viscosity of the oil.\n",
        "\n",
        "  Returns:\n",
        "    The load carrying capacity.\n",
        "  \"\"\"\n",
        "\n",
        "  return (np.pi * P0(x) / 2) * ((x[3]**2 - x[2]**2) / np.log(x[2] / x[1]))\n",
        "\n",
        "def P0(x):\n",
        "  \"\"\"Calculates the inlet pressure.\n",
        "\n",
        "  Args:\n",
        "    x: A NumPy array containing the following variables:\n",
        "      x[0]: The inlet pressure.\n",
        "      x[1]: The outlet pressure.\n",
        "      x[2]: The oil thickness.\n",
        "      x[3]: The viscosity of the oil.\n",
        "\n",
        "  Returns:\n",
        "    The inlet pressure.\n",
        "  \"\"\"\n",
        "  return ((6e-6 * x[3] * x[0]) / (np.pi * h(x)**3)) * np.log(x[2] / x[1])\n",
        "\n",
        "def Ef(x):\n",
        "  \"\"\"Calculates the friction loss.\n",
        "\n",
        "  Args:\n",
        "    x: A NumPy array containing the following variables:\n",
        "      x[0]: The inlet pressure.\n",
        "      x[1]: The outlet pressure.\n",
        "      x[2]: The oil thickness.\n",
        "      x[3]: The viscosity of the oil.\n",
        "\n",
        "  Returns:\n",
        "    The friction loss.\n",
        "  \"\"\"\n",
        "\n",
        "  return 143.308 * delta_t(x)*x[0]\n",
        "\n",
        "def delta_t(x):\n",
        "  return 2 * (np.power(10, P(x)) - 560)\n",
        "\n",
        "def f(x):\n",
        "\n",
        "  minimums = np.minimum(((P0(x) * x[0] / 0.7) + Ef(x)), x)\n",
        "  return minimums\n",
        "\n",
        "\n",
        "def h(x):\n",
        "  \"\"\"Calculates the oil thickness.\n",
        "\n",
        "  Args:\n",
        "    x: A NumPy array containing the following variables:\n",
        "      x[0]: The inlet pressure.\n",
        "      x[1]: The outlet pressure.\n",
        "      x[2]: The oil thickness.\n",
        "      x[3]: The viscosity of the oil.\n",
        "\n",
        "  Returns:\n",
        "    The oil thickness.\n",
        "  \"\"\"\n",
        "\n",
        "  return ((1500 * np.pi / 60)**2) * (2e-6 * np.pi * x[3] / Ef(x)) * ((x*Fraction(4, 3) / 4) - (x*Fraction(4, 2) / 4))\n",
        "\n",
        "def g1(x):\n",
        "  \"\"\"Calculates the first constraint function.\"\"\"\n",
        "  return 101000 - W(x)\n",
        "\n",
        "def g2(x):\n",
        "  \"\"\"Calculates the second constraint function.\"\"\"\n",
        "  return P0(x) - 1000\n",
        "\n",
        "def g3(x):\n",
        "  \"\"\"Calculates the third constraint function.\"\"\"\n",
        "  return delta_t(x) - 50\n",
        "\n",
        "def g4(x):\n",
        "  \"\"\"Calculates the fourth constraint function.\"\"\"\n",
        "  return 0.001 - h(x)\n",
        "\n",
        "def g5(x):\n",
        "  \"\"\"Calculates the fifth constraint function.\"\"\"\n",
        "  return x[1] - x[2]\n",
        "\n",
        "def g6(x):\n",
        "  \"\"\"Calculates the sixth constraint function.\"\"\"\n",
        "  return ((0.0307 * x[0]) / (772.8 * np.pi * P0(x) * h(x) * x[2])) - 0.001\n",
        "\n",
        "def g7(x):\n",
        "  \"\"\"Calculates the seventh constraint function.\"\"\"\n",
        "\n",
        "  return (W(x) / np.pi * (x*Fraction(2, 3) - x*Fraction(2, 2))) - 5000"
      ],
      "metadata": {
        "id": "9Q3ubMpOVdK9"
      },
      "execution_count": 50,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# RANDOM SEARCH IMPLEMENTATION\n",
        "def random_search(f, x_array, seed=np.random.seed(48), lb=1, ub=16, max_evals=10_000, constraint_functions=[]):\n",
        "    \"\"\"\n",
        "    f: objective function to be optimized\n",
        "    seed: random seed for reproducibility\n",
        "    lb: lower bound of our search space\n",
        "    ub: upper bound of our search space\n",
        "    max_evals: maximum number of evaluations\n",
        "    \"\"\"\n",
        "\n",
        "    np.random.seed(seed)\n",
        "\n",
        "    best_x = None\n",
        "    best_f = np.inf\n",
        "\n",
        "    # Ensure we working with array at all times (just a little safeguard)\n",
        "    search_space = np.array(x_array)\n",
        "\n",
        "    evals = 0 # number of evaluations\n",
        "\n",
        "    # loop until max_evals\n",
        "    while evals < max_evals:\n",
        "        # generate random x\n",
        "        x = np.random.uniform(search_space, size=len(x_array))\n",
        "\n",
        "        x = np.clip(x, lb, ub)\n",
        "\n",
        "        # check if constraint is satisfied\n",
        "        constraints = [g(x) for g in constraint_functions]\n",
        "        if np.all(c<= 0 for c in constraints):\n",
        "          fx = f(x)\n",
        "\n",
        "          # update best_x and best_f if necessary\n",
        "          if np.all(fx < best_f):\n",
        "              best_x = x\n",
        "              best_f = fx\n",
        "          # increment evals\n",
        "          evals += 1\n",
        "\n",
        "    return best_x, best_f\n"
      ],
      "metadata": {
        "id": "5gR82V3BVdOL"
      },
      "execution_count": 102,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# SIMULATED ANNEALING IMPLEMENTATION\n",
        "\n",
        "def simulated_annealing(f, initial_solution, seed=np.random.seed(48), max_iterations=10_000, control_parameter=1):\n",
        "    \"\"\"\n",
        "    f: objective function to be optimized\n",
        "    seed: random seed for reproducibility\n",
        "    initial_solution: initial solution from which we start our search (this comes from our random search)\n",
        "    max_iterations: maximum number of iterations (stop criterion)\n",
        "    control_parameter: control parameter for simulated annealing (temperature)\n",
        "    \"\"\"\n",
        "\n",
        "    cool_rate = 0.95\n",
        "\n",
        "    np.random.seed(seed)\n",
        "\n",
        "    current_solution = initial_solution\n",
        "    current_value = f(current_solution)\n",
        "\n",
        "    best_solution = current_solution\n",
        "    best_value = current_value\n",
        "\n",
        "    for _ in range(max_iterations):\n",
        "        # Generate a new solution\n",
        "        neighbour_solution = current_solution + np.random.uniform(0, 1) # Keeping our new decision space within our constraints\n",
        "        neighbour_value = f(neighbour_solution)\n",
        "\n",
        "        # Accept or reject the new solution based on acceptance probability\n",
        "        acceptance_prob = accept_p(neighbour_value, current_value, control_parameter)\n",
        "        if np.random.rand() < acceptance_prob:\n",
        "            current_solution = neighbour_solution\n",
        "            current_value = neighbour_value\n",
        "\n",
        "        # Update the best solution if the current solution is better\n",
        "        if current_value < best_value:\n",
        "            best_solution = current_solution\n",
        "            best_value = current_value\n",
        "\n",
        "        # Cool the temperature\n",
        "        control_parameter *= cool_rate\n",
        "\n",
        "    return best_solution, best_value\n",
        "\n",
        "def accept_p(neighbour_solution, current_solution, control_parameter):\n",
        "    \"\"\"\n",
        "    Acceptance probability for the Simulated annealing method.\n",
        "\n",
        "    neighbour_solution: new solution\n",
        "    current_solution: current solution\n",
        "    control_parameter: control parameter for simulated annealing (temperature)\n",
        "    \"\"\"\n",
        "    if np.any(neighbour_solution < current_solution):\n",
        "        return 1  # accept new solution\n",
        "    else:\n",
        "        return np.exp(-(neighbour_solution - current_solution) / control_parameter)  # accept new solution with probability"
      ],
      "metadata": {
        "id": "N176Tq_BWd4f"
      },
      "execution_count": 103,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# VALIDATION CODE\n",
        "\n",
        "x = np.array([4.19, 11.57, 6.69, 10.65])\n",
        "\n",
        "print(\"Objective function output, f(x) = \", f(x))\n",
        "print(\"Constraint function output, g1(x) = \", g1(x))\n",
        "print(\"Constraint function output, g2(x) = \", g2(x))\n",
        "print(\"Constraint function output, g3(x) = \", g3(x))\n",
        "print(\"Constraint function output, g4(x) = \", g4(x))\n",
        "print(\"Constraint function output, g5(x) = \", g5(x))\n",
        "print(\"Constraint function output, g6(x) = \", g6(x))\n",
        "print(\"Constraint function output, g7(x) = \", g7(x))\n",
        "\n",
        "constraint_functions = [g1, g2, g3, g4, g5, g6, g7]\n",
        "# test the random search\n",
        "best_x, best_f = random_search(f, x, seed=420, max_evals=10_000, constraint_functions=constraint_functions)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aFmcSLbSVdU-",
        "outputId": "c7c716ff-a84c-4cc8-f98d-b7c744b4f9f2"
      },
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Objective function output, f(x) =  [-66258374.6794144 -3148598.097346256 -16279475.07768886\n",
            " -4036587.029849999]\n",
            "Constraint function output, g1(x) =  [-2179384118.4763093 -103412239.44704632 -535347398.0628562\n",
            " -132622294.57011858]\n",
            "Constraint function output, g2(x) =  [-11070120.148375956 -526720.7193908262 -2720423.317538755\n",
            " -675072.0923628119]\n",
            "Constraint function output, g3(x) =  -52.97118117373543\n",
            "Constraint function output, g4(x) =  [0.0008384308579466824 0.0005538532282680466 0.0007420292218766839\n",
            " 0.0005893290303418061]\n",
            "Constraint function output, g5(x) =  4.88\n",
            "Constraint function output, g6(x) =  [-0.0010000044283075384 -0.0010000337657535443 -0.0010000112891687231\n",
            " -0.001000028609412784]\n",
            "Constraint function output, g7(x) =  [-968944818.4687054 -127079418.6640295 -380082896.57763827\n",
            " -149982335.59936023]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# TESTING, TESTING, LET'S SEE IF OUR CONSTRAINTS WERE THROUGHLY WORKING\n",
        "# You would have to run this a few times to get the desired results, this is to solely test fully randomized values\n",
        "# within search space given by our constraint functions\n",
        "\n",
        "def validate_constraints():\n",
        "    # Generate random decision vector within [1, 16]\n",
        "    decision_vector = np.random.uniform(1, 16, 4)\n",
        "    print(decision_vector)\n",
        "\n",
        "    decision_vector = np.array(decision_vector)\n",
        "    # Check each constraint\n",
        "    for g in [ g1, g2, g3, g4, g5, g6, g7]:\n",
        "        result = g(decision_vector)\n",
        "        print(result)\n",
        "        assert np.all(result <= 16), f\"Constraint {g.__name__} is not less than or equal to 16.\"\n",
        "\n",
        "validate_constraints()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UVUdWN4kt0zp",
        "outputId": "e173bb61-c5a0-4c42-8bdc-7fe51fe31d65"
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[ 6.9215797   7.51459555 13.99021536  6.74825204]\n",
            "[-22287759575440.72 -17416675234904.268 -2699037216884.9146\n",
            " -24049619087514.85]\n",
            "[-58716799241.71787 -45883994123.84854 -7110577923.917389\n",
            " -63358394045.43703]\n",
            "-18.99480537587715\n",
            "[0.00100981058214954 0.0010106511172463305 0.0010198296000268037\n",
            " 0.0010095649091527697]\n",
            "-6.4756198089149235\n",
            "[-0.0009999999891396189 -0.0009999999871989427 -0.0009999999556306138\n",
            " -0.0009999999896767317]\n",
            "[-16368184551319.973 -13886721948150.867 -4006472463785.881\n",
            " -17219810647901.156]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Perform random search and simulated annealing simulations, 21 times\n",
        "search_results = [random_search(f, x, seed=i, constraint_functions=constraint_functions) for i in range(21)]\n"
      ],
      "metadata": {
        "id": "oO1z1qoNm46U"
      },
      "execution_count": 107,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "selected = search_results[0][1] # Could be vector from our search result\n",
        "print(selected)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ibaCRdoXYTuY",
        "outputId": "a6a2ca99-063f-4a2d-b5f7-3340972786ea"
      },
      "execution_count": 108,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[-2485127103557136.0 -1.3689958442495283e+17 -1243049197536691.5\n",
            " -5.379896296762006e+16]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sa_results = (-0.9891172937981292, 0.00011843329427618787)\n",
        "print(sa_results)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DpPSTSamX2ZW",
        "outputId": "d0478700-2595-4201-d205-2d8bbbf485e0"
      },
      "execution_count": 112,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(-0.9891172937981292, 0.00011843329427618787)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(search_results)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KyMiLFh_qII9",
        "outputId": "93236385-4780-48ef-e2c9-09ad5c34d5a3"
      },
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(array([4.07129679, 1.06999461, 5.12884443, 1.4608008 ]), array([-2485127103557136.0, -1.3689958442495283e+17, -1243049197536691.5,\n",
            "       -5.379896296762006e+16], dtype=object)), (array([3.03623693, 1.0880015 , 5.75665322, 1.01212254]), array([-6485521026898226.0, -1.4094944507512322e+17, -951571974269462.4,\n",
            "       -1.7508645723586557e+17], dtype=object)), (array([3.84438326, 1.13921369, 4.78684341, 1.00771266]), array([-9115171437503104.0, -3.502912472813047e+17, -4721687195543037.0,\n",
            "       -5.0609812607241043e+17], dtype=object)), (array([3.97151182, 1.1556537 , 4.02458381, 1.12688564]), array([-5419365521973813.0, -2.1995451399008234e+17, -5207785597176550.0,\n",
            "       -2.3723375706271978e+17], dtype=object)), (array([3.92989749, 1.42617711, 5.38981445, 1.03891672]), array([-7817708321276711.0, -1.635696562023054e+17, -3030412056845819.0,\n",
            "       -4.231369251851768e+17], dtype=object)), (array([3.80693754, 1.02622514, 2.14786889, 1.15282906]), array([-2690409915647804.5, -1.3734655113289734e+17,\n",
            "       -1.4980365456532092e+16, -9.68837545645924e+16], dtype=object)), (array([3.76794655, 1.0836048 , 2.99519471, 1.01537917]), array([-6018409890048803.0, -2.5303651655779728e+17,\n",
            "       -1.1981764552907236e+16, -3.075468001561681e+17], dtype=object)), (array([3.9771898 , 2.03659538, 5.04565452, 1.07235981]), array([-4817293619430596.0, -3.5877139398973548e+16, -2359280274251041.0,\n",
            "       -2.4575959783087443e+17], dtype=object)), (array([3.1007346 , 1.03562481, 2.68095992, 1.06580985]), array([-3145605277966910.0, -8.442881003810886e+16, -4866615624988564.0,\n",
            "       -7.745666937882606e+16], dtype=object)), (array([3.94634118, 1.02522408, 4.99949532, 1.0743266 ]), array([-8222734191992391.0, -4.6896858137070483e+17, -4044097720425106.0,\n",
            "       -4.0755962373398426e+17], dtype=object)), (array([4.03289097, 1.4895555 , 3.47512281, 1.04914311]), array([-5045773151672811.0, -1.001398864044294e+17, -7886180149255073.0,\n",
            "       -2.8659787147453517e+17], dtype=object)), (array([3.84063641, 1.5541427 , 5.26656632, 1.02203841]), array([-7314045026632695.0, -1.103810540743885e+17, -2836511452317130.5,\n",
            "       -3.88119582894901e+17], dtype=object)), (array([3.65803872, 1.66997345, 2.55631249, 1.01691059]), array([-2361243340129086.0, -2.481743761092016e+16, -6919007732143217.0,\n",
            "       -1.0991003202462555e+17], dtype=object)), (array([4.04876262, 1.08070277, 2.78367562, 1.24000347]), array([-2905086319835026.5, -1.527591356026826e+17, -8938612432529879.0,\n",
            "       -1.0112470880521782e+17], dtype=object)), (array([4.14984538, 1.1181892 , 5.73475978, 1.02613881]), array([-1.1258414034939272e+16, -5.754758260136182e+17,\n",
            "       -4266063041455820.0, -7.446541679654607e+17], dtype=object)), (array([3.72513858, 2.04557767, 2.81731695, 1.0318311 ]), array([-1737768137701000.8, -1.0494728495423322e+16, -4017094114181801.0,\n",
            "       -8.176986624515366e+16], dtype=object)), (array([4.06837487, 1.30652203, 6.06984459, 1.03591338]), array([-9791204775369172.0, -2.956302121198471e+17, -2948263570280053.5,\n",
            "       -5.93101054868799e+17], dtype=object)), (array([3.26329892, 1.05748803, 2.48909371, 1.02049151]), array([-3725926552972046.0, -1.0949101514146229e+17, -8396167967639452.0,\n",
            "       -1.2183629210037707e+17], dtype=object)), (array([4.12548627, 1.82713208, 4.89677867, 1.01076174]), array([-7122944472160848.0, -8.199269683272136e+16, -4259450473390741.5,\n",
            "       -4.843269273292343e+17], dtype=object)), (array([4.04395984, 1.52647878, 4.13108763, 1.02111302]), array([-6638602053580043.0, -1.2343116517854986e+17, -6227359220245784.0,\n",
            "       -4.123592035647938e+17], dtype=object)), (array([3.90734524, 1.16581891, 5.72992672, 1.03963681]), array([-9230235726543958.0, -3.4750804739313024e+17, -2926920650432631.5,\n",
            "       -4.900193188198019e+17], dtype=object))]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# GRAPH PLOTTING\n",
        "\n",
        "# Generic plotting method that takes in results from a\n",
        "# Simulated Annealing process and a random search and\n",
        "# plot both results on a pretty 2D-Canvas\n",
        "def plot_graph(search_results, sim_results) -> None:\n",
        "    data = [search_results, sim_results]\n",
        "    labels = ['Random Search', 'Simulated Annealing']\n",
        "\n",
        "    fig, ax = plt.subplots()\n",
        "    ax.boxplot(data, vert=True, patch_artist=True, labels=labels)\n",
        "\n",
        "    ax.set_title('Optimization Algorithm - Comparison')\n",
        "    ax.set_ylabel('Objective Function Value')\n",
        "    ax.set_xlabel('Algorithm')\n",
        "\n",
        "    plt.show()\n",
        "\n",
        "plot_graph(search_results=[-2485127103557136.0 -1.3689958442495283e+17 -1243049197536691.5\n",
        " -5.379896296762006e+16], sim_results=sa_results)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "CYKM8GlHVdqh",
        "outputId": "8c188caa-a48f-4f8e-ce74-aba40f1903a9"
      },
      "execution_count": 116,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}