abc_artificial_bee_colony_algorithm.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "abc_artificial_bee_colony_algorithm.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyMyfGUCb2ML0Lt2wDh/hHsj",
      "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/AjayKadoula/Mtech_Lab_1/blob/main/abc_artificial_bee_colony_algorithm.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bmA60qzB7eVR"
      },
      "source": [
        "# **Artificial Bee Colony Algorithm (ABC)**\n",
        "\n",
        "In computer science and operations research, the artificial bee colony algorithm (ABC) is an optimization algorithm based on the intelligent foraging behaviour of honey bee swarm, proposed by Karaboga in 2005.\n",
        "\n",
        "In the ABC algorithm, there are three types of bees: employed bees, onlooker bees, and scout bees. The employed bees search food around the food source in their memory; meanwhile they share the information of these food sources to the onlooker bees. The onlooker bees tend to select good food sources from those found by the employed bees. The food source that has higher quality (fitness) will have a large chance to be selected by the onlooker bees than the one of lower quality. The scout bees are translated from a few employed bees, which abandon their food sources and search new ones\n",
        "\n",
        "In the ABC algorithm, the first half of the swarm consists of employed bees, and the second half constitutes the onlooker bees.\n",
        "\n",
        "The number of employed bees or the onlooker bees is equal to the number of solutions in the swarm. The ABC generates a randomly distributed initial population of SN solutions (food sources), where SN denotes the swarm size.\n",
        "\n",
        "Let  Xi={xi,1,xi,2,…,xi,n}  represent the  ith  solution in the swarm, Where  n is the dimension size. Each employed bee  Xi generates a new candidate solution  Vi  in the neighborhood of its present position as equation below:\n",
        "\n",
        "Vik=Xik+Φik×(Xik−Xjk) \n",
        "\n",
        "Where  Xj  is a randomly selected candidate solution ( i≠j ),  k  is a random dimension index selected from the set  {1,2,…,n}  , and  Φik  is a random number within  [−1,1] . Once the new candidate solution  Vi  is generated, a greedy selection is used. If the fitness value of  Vi  is better than that of its parent  Xi , then update  Xi  with  Vi ; otherwise keep  Xi  unchanged. After all employed bees complete the search process; they share the information of their food sources with the onlooker bees through waggle dances. An onlooker bee evaluates the nectar information taken from all employed bees and chooses a food source with a probability related to its nectar amount. This probabilistic selection is really a roulette wheel selection mechanism which is described as equation below:\n",
        "\n",
        "Pi=fiti/∑jfitj \n",
        "\n",
        "Where  fiti  is the fitness value of the  ith solution in the swarm. As seen, the better the solution  i , the higher the probability of the  ith food source selected. If a position cannot be improved over a predefined number (called limit) of cycles, then the food source is abandoned. Assume that the abandoned source is  Xi , and then the scout bee discovers a new food source to be replaced with  ith  as equation below:\n",
        "\n",
        "Xik=lbj+rand(0,1)×(ubj−lbj) \n",
        "\n",
        "Where  rand(0,1)  is a random number within [0,1]  based on a normal distribution and  lb,ub , are lower and upper boundaries of the  ith  dimension, respectively.\n",
        "\n",
        "\n",
        "**Population** - the total number of sampling points of your objective function per iteration\n",
        "\n",
        "**Bee** - a single sampling point\n",
        "\n",
        "**Food** - the value of the objective function at the sampling point.\n",
        "\n",
        "Scout Bees simply randomly probe the search space within bounds, and worker bees perform local optimisation around the current best solutions.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "8VnFMzKO7doM",
        "outputId": "83c888a6-122b-453e-e521-61180b55980a"
      },
      "source": [
        "\n",
        "import random\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "# optimize y = x ^ 2 for x in [-500, 500]\n",
        "\n",
        "def find_max_index(my_list):\n",
        "    index = 0\n",
        "    max_value = my_list[index]\n",
        "    for i in range(len(my_list)):\n",
        "        if my_list[i] > max_value:\n",
        "            max_value = my_list[i]\n",
        "            index = i\n",
        "    return index\n",
        "\n",
        "N_w = 50    # number of workers\n",
        "N_s = 10    # number of scouts\n",
        "N_all = N_w + N_s   # number of all the bees\n",
        "max_limit = 10\n",
        "max_opt_iter = 100\n",
        "pos_list = []\n",
        "fitness_list = []\n",
        "limit_list = []\n",
        "opt_fitness_list = []\n",
        "\n",
        "# initialization\n",
        "for i in range(N_all):\n",
        "    pos = 1000*(random.random()-0.5)\n",
        "    pos_list.append(pos)\n",
        "    fitness = -pos * pos\n",
        "    fitness_list.append(fitness)\n",
        "    limit_list.append(0)\n",
        "\n",
        "\n",
        "index = find_max_index(fitness_list)\n",
        "g_best_pos = pos_list[index]\n",
        "g_best_fitness = fitness_list[index]\n",
        "\n",
        "print(g_best_fitness)\n",
        "# start optimization\n",
        "for opt_iter in range(max_opt_iter):\n",
        "    #print(opt_iter)\n",
        "    for i in range(N_w):\n",
        "        # choose a neighbour\n",
        "        neigh_index = random.randint(0, N_all - 1)\n",
        "        while neigh_index == i:\n",
        "            neigh_index = random.randint(0, N_all - 1)\n",
        "\n",
        "        # calculate new pos\n",
        "        temp_pos = pos_list[i] + 2*(random.random()-0.5)*(pos_list[neigh_index] - pos_list[i])\n",
        "\n",
        "        # bound new pos\n",
        "        if temp_pos > 500:\n",
        "            temp_pos = 500\n",
        "        if temp_pos < -500:\n",
        "            temp_pos = -500\n",
        "\n",
        "        # calculate fitness\n",
        "        temp_fitness = -temp_pos * temp_pos\n",
        "\n",
        "        # update self fitness and pos\n",
        "        if temp_fitness > fitness_list[i]:\n",
        "            fitness_list[i] = temp_fitness\n",
        "            pos_list[i] = temp_pos\n",
        "            limit_list[i] = 0\n",
        "        else:\n",
        "            limit_list[i] = limit_list[i] + 1\n",
        "\n",
        "        if limit_list[i] > max_limit:\n",
        "            pos_list[i] = 1000*(random.random()-0.5)\n",
        "\n",
        "    for i in range(N_w, N_w+N_s):\n",
        "        # choose a new pos\n",
        "        pos_list[i] = 1000 * (random.random() - 0.5)\n",
        "\n",
        "        # calculate fitness\n",
        "        fitness_list[i] = -pos_list[i] * pos_list[i]\n",
        "\n",
        "    # update global best pos\n",
        "    index = find_max_index(fitness_list)\n",
        "    if fitness_list[index] > g_best_fitness:\n",
        "        g_best_pos = pos_list[index]\n",
        "        g_best_fitness = fitness_list[index]\n",
        "\n",
        "    opt_fitness_list.append(g_best_fitness)\n",
        "\n",
        "x = range(max_opt_iter)\n",
        "plt.plot(x, opt_fitness_list)\n",
        "plt.show()"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-0.5065308163532873\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"
          }
        }
      ]
    }
  ]
}