ABC 101 (Function Only).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Artificial Bee Colony Optimization "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#------------------------------------------------------------------------------+\n",
    "#   CHIA E TUNGOM\n",
    "#   Artificial Bee Colony (ABC) Algorithm with Python\n",
    "#   Feb, 2020\n",
    "#------------------------------------------------------------------------------+"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import dependensies\n",
    "\n",
    "import random\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# 1. Start by defining the search bound then generate vectors with given predefined dimensions \n",
    "\n",
    "dim = 4                                                 # dimension of vector\n",
    "pop = 5\n",
    "limit = 4                                               # maximum number of visits to any Bee \n",
    "bound = [(-10, 10)]                                     # (lower, upper) bound for one dimensional vector\n",
    "bounds = [(-10, 10) for i in range(dim)]                # for a 3 dimensionsal vector\n",
    "\n",
    "print(bounds)\n",
    "\n",
    "# 2. generate a population of random vectors (X) within the bound each with dimension D (dim) and set limit values(Trials)\n",
    "#   for each \n",
    "# x(i,j) = l(j) + rand(0,1)*(u(i) - u(j))  ...... Eq1        # use to generate initial population of Bee Colony\n",
    "\n",
    "X = [[bounds[i][0] + ( random.uniform(0,1)*(bounds[i][1] - bounds[i][0]) ) for i in range(dim)] for i in range(pop)]\n",
    "\n",
    "# X = [[random.uniform(bounds[i][0], bounds[i][1]) for i in range(dim)] for i in range(pop)]    # Alternative random generation\n",
    "\n",
    "Trials =[0 for i in range(pop)]\n",
    "\n",
    "X\n",
    "Trials"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Employee Bee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3. v(i,j) = x(i,j) + phi (x(i,j)-x(r,j)) ....... Eq2\n",
    "\n",
    "#    phi [-1,1]    r != i\n",
    "\n",
    "# 4. Define objective function \n",
    "\n",
    "def sphere(x):\n",
    "    ans = 0\n",
    "    for i in range(len(x)):\n",
    "        ans += x[i]**2\n",
    "        \n",
    "    return ans\n",
    "\n",
    "\n",
    "# Employee Bee\n",
    "def EBee(X, f, Trials, phi = 0.3):\n",
    "\n",
    "    for i in range(len(X)):\n",
    "        \n",
    "        V = []\n",
    "        R  = X.copy()\n",
    "        R.remove(X[i])\n",
    "        r = random.choice(R)\n",
    "        \n",
    "        for j in range(len(X[0])):   # x[0] or number of dimensions\n",
    "            \n",
    "             V.append( (X[i][j] + random.uniform(-1,1)*(X[i][j] - r[j])) )\n",
    "                                                          # idea for r, can pick a random particle for every dimendo\n",
    "        if f(X[i]) < f(V):\n",
    "            Trials[i] += 1\n",
    "            \n",
    "        else:\n",
    "            X[i] = V\n",
    "            Trials[i] = 0\n",
    "            \n",
    "    #print(Trials)       \n",
    "    return X, Trials"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Onlooker Bee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# P(i) = ( 1 / 1 + f(x) ) / (sum(1..n) 1 / 1 + f(x(n) ) )     Pi is used to choose an onlooker bee \n",
    "\n",
    "def P(X, f):\n",
    "    \n",
    "    P = []\n",
    "    sP = sum ([1 / (1 + f(i) ) for i in X])\n",
    "    for i in range(len(X)):\n",
    "        \n",
    "        P.append(  (1 / (1 + f(X[i]) ) )/  sP )\n",
    "        \n",
    "    return P\n",
    "\n",
    "# Onlooker Bee\n",
    "def OBee(X, f, Trials, phi = 0.3):\n",
    "    \n",
    "    Pi  =  P(X, f)\n",
    " \n",
    "    for i in range(len(X)):\n",
    "#---------------------------------------------------------------------------------*\n",
    "#              chose a bee by probability p\n",
    "#---------------------------------------------------------------------------------*\n",
    "        if random.random() < Pi[i]:\n",
    "            \n",
    "            V = []\n",
    "            R  = X.copy()\n",
    "            R.remove(X[i])\n",
    "            r = random.choice(R)\n",
    "#----------------------------------------------------------------------------------*\n",
    "            for j in range(len(X[0])):   # x[0] or number of dimensions\n",
    "                \n",
    "                V.append ( (X[i][j] + random.uniform(-1,1)*(X[i][j] - r[j])) )\n",
    "            \n",
    "            if f(X[i]) < f(V):\n",
    "                Trials[i] += 1\n",
    "            \n",
    "            else:\n",
    "                X[i] = V\n",
    "                Trials[i] = 0\n",
    "    #print (Trials)   \n",
    "    return X, Trials"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scout Bee "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scout Bee\n",
    "def SBee(X, Trials, bounds, limit=3):\n",
    "    #print (Trials)\n",
    "    \n",
    "    for i in range(len(X)):\n",
    "    \n",
    "        if Trials[i] > limit :\n",
    "            Trials[i] = 0\n",
    "            X[i] = [bounds[i][0] + ( random.uniform(0,1)*(bounds[i][1] - bounds[i][0]) ) for i in range(len(X[0]))]\n",
    "        \n",
    "    return X  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Putting It All Together (ABC Algorithm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Putting it all together \n",
    "\n",
    "def ABC(dims, bounds, f, limit = 4, pop =20 , runs = 20):\n",
    "    \n",
    "    bounds = [(-10, 10) for i in range(dims)]                # for a 3 dimensionsal vector\n",
    "\n",
    "    X = [[bounds[i][0] + ( random.uniform(0,1)*(bounds[i][1] - bounds[i][0]) ) for i in range(dims)] for i in range(pop)]\n",
    "\n",
    "    Trials = [0 for i in range(pop)]\n",
    "    \n",
    "    \n",
    "    while runs > 0:\n",
    "        \n",
    "        X, Trials= EBee(X, f, Trials)\n",
    "        \n",
    "        X, Trials= OBee (X, f, Trials)\n",
    "        \n",
    "        X = SBee(X, Trials, bounds, limit)\n",
    "        \n",
    "        runs -= 1\n",
    "        \n",
    "    fx = [f(i) for i in X]\n",
    "    I = fx.index(min(fx))     # find index of best position \n",
    "    print(X[I])\n",
    "    \n",
    "    return min(fx)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimize the Sphere Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.00183032626321277, 0.0018857262683868769, 0.003964787072727653, -0.00020603154045145195, -0.00043705998622975623]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2.285906474838298e-05"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 5\n",
    "bound = [(-10,10)]\n",
    "\n",
    "ABC(dimensions, bound, sphere, limit=50, pop =20 , runs= 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the funtions \n",
    "\n",
    "def sphere(x):\n",
    "    ans = 0\n",
    "    for i in range(len(x)):\n",
    "        ans += x[i]**2\n",
    "        \n",
    "    return ans\n",
    "\n",
    "\n",
    "def wsphere(x):\n",
    "    ans  = 0\n",
    "    for i in range(len(x)):\n",
    "        ans += i*(x[i]**2)\n",
    "        \n",
    "    return ans\n",
    "\n",
    "def schewefels(x):\n",
    "    ans = 0\n",
    "    for i in range(len(x)):\n",
    "        ans += sphere(x) \n",
    "    return ans \n",
    "\n",
    "def rhellipsoid(x):\n",
    "    ans  = 0\n",
    "    for i in range(len(x)):\n",
    "        fx = 0\n",
    "        for i in range(len(x)):\n",
    "            fx += x[i]\n",
    "        ans += fx**2\n",
    "    return ans \n",
    "\n",
    "def rosenbrock(x):\n",
    "    ans  = 0\n",
    "    for i in range(len(x)-1):\n",
    "        ans += (100 * ( x[i+1] - x[i] )**2) + (x[i]-1)**2\n",
    "    return ans\n",
    "        \n",
    "def esom(x):\n",
    "    ans  = ( -math.cos(x[0])*math.cos(x[1]) ) * math.exp( -( (x[0] - math.pi)**2 + (x[1] - math.pi) ))\n",
    "    return ans\n",
    "    \n",
    "def brain(x):\n",
    "    ans = (x[1]- ( (5.1/4*(math.pi**2))*(x[0]**2)) + (5.1/(4*(math.pi)) )*(x[0]) - 6)**2 + \\\n",
    "    10*(1 - (1/(8*math.pi))*math.cos(x[0])) + 10\n",
    "    return ans \n",
    "    \n",
    "def rastrigen(x):\n",
    "    ans  = 0\n",
    "    for i in range (len(x)):\n",
    "        ans += x[i]**2 - 10*( math.cos(2*math.pi*x[i]) ) + 10\n",
    "    return ans   \n",
    "\n",
    "def griewank(x):\n",
    "    ans = 0\n",
    "    a = 0\n",
    "    b = 1\n",
    "    for i in range(len(x)):\n",
    "        a += x[i]**2\n",
    "        b *= math.cos( x[i] / ((i+1)**(1/2)) )\n",
    "    ans = ( (1/4000)*a ) + b + 1\n",
    "    return ans \n",
    "\n",
    "def aukley(x):\n",
    "    a = 0\n",
    "    b = 0\n",
    "    ans = 0\n",
    "    for i in range(len(x)):\n",
    "        a += x[i]**2\n",
    "        b += math.cos( 2*math.pi*x[i])\n",
    "    ans = (-20*math.exp((-0.2)*(math.sqrt( (1/len(x)) *a)) ) )- math.exp( (1/len(x)) * b ) + 20 + math.e\n",
    "    return ans\n",
    "\n",
    "\n",
    "def schewefels2(x):\n",
    "    ans = 0\n",
    "    a = 0\n",
    "    b = 1\n",
    "    for i in range(len(x)):\n",
    "        a += x[i]\n",
    "        b *= x[i]\n",
    "    ans = a + b \n",
    "    return ans \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-2029.7866297058167, 0.0004027744311810023, -0.00045381574399364847, 0.0006514817074964556, -0.00015541359034675886]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.9440234832715703e-06"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 5\n",
    "bound = [(-10,10)]\n",
    "\n",
    "ABC(dimensions, bound, wsphere, limit=50, pop =20 , runs= 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0010664823120540043, 0.0005381791855229622, -0.0023862592495495984, -0.00243652253600538, 0.001837809018544823]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8.217719310410998e-05"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 5\n",
    "bound = [(-10,10)]\n",
    "\n",
    "ABC(dimensions, bound, schewefels, limit=50, pop =20 , runs= 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7.747260531345819, 1.2361001988662383, -9.122542961185268, -3.1158542713343547, 3.2592859521351247]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "9.02891191847407e-05"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 5\n",
    "bound = [(-10,10)]\n",
    "\n",
    "ABC(dimensions, bound, rhellipsoid, limit=50, pop =20 , runs= 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.152422974071516, -1.0338520836448968, -1.396448260906687, -1.127223489089417, -1.143834998968128]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "40.86681938138766"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 5\n",
    "bound = [(-10,10)]\n",
    "\n",
    "ABC(dimensions, bound, rosenbrock, limit=50, pop =20 , runs= 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.00010964873130239419, 6.000060299004725, 20.575287606087727, 95.51737099468131, 0.36792992956592124]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "19.60211264490697"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 5\n",
    "bound = [(-10,10)]\n",
    "\n",
    "ABC(dimensions, bound, brain, limit=50, pop =20 , runs= 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.018530379463286284, 1.0822907000190005, -2.003189079052651, -0.9809272986339626, -0.04938484316021746]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8.075288384634858"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 5\n",
    "bound = [(-10,10)]\n",
    "\n",
    "ABC(dimensions, bound, rastrigen, limit=50, pop =20 , runs= 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-6.873635429962183, -13.502492506257653, -10.602273840921345, 0.3958481772663316, -0.5686495730795684]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.31352239996017284"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 5\n",
    "bound = [(-10,10)]\n",
    "\n",
    "ABC(dimensions, bound, griewank, limit=50, pop =20 , runs= 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0001153787978088747, 0.0012704011011386517, -0.0010980797181341735, 5.566385581481405e-05, -0.0007347599884469754]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.0033227712864634107"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 5\n",
    "bound = [(-10,10)]\n",
    "\n",
    "ABC(dimensions, bound, aukley, limit=50, pop =20 , runs= 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-154051527.62709403, 1292053335.7127333, 338154.38398648537, -30545168.730170913, -28986371.074306015]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-5.959335679459029e+37"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dimensions = 5\n",
    "bound = [(-10,10)]\n",
    "\n",
    "ABC(dimensions, bound, schewefels2, limit=50, pop =20 , runs= 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}