ecs-basecode-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing necessary libraries to use\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import norm\n",
    "from scipy.special import gamma as gamma_function\n",
    "import math\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Constrution of a class called \"Cuckoo\" which contains the main function.\n",
    "class Cuckoo():\n",
    "    \n",
    "    # Constant Parameters\n",
    "    X_min = 0            # test area lower bound\n",
    "    X_max = 100          # test area upper bound\n",
    "    alpha_min = 0.9      # step size lower bound\n",
    "    alpha_max = 1.0      # step size upper bound\n",
    "    pa_min = 0.05        # mutation probability lower bound\n",
    "    pa_max = 0.25        # mutation probability upper bound\n",
    "    N_nest = 25          # total no. of solutions in the test field\n",
    "    N_itertotal = 100    # max. no. of iterations for each node localization\n",
    "    gamma = 0.1          # noise factor\n",
    "    lamda = 1.5          # constant used in le'vy flight\n",
    "    \n",
    "    total_nodes = 0      # node density\n",
    "    anchor_percent = 0   # anchor ratio\n",
    "    t_range = 0          # transmission range\n",
    "    \n",
    "    X_anchor = []        # anchor list\n",
    "    X_unknown = []       # unknown nodes list\n",
    "    \n",
    "    X_loc = []           # (estimated coords, actual coords) pairs\n",
    "    F_mins = []          # iteration-wise optimum fitness values\n",
    "    \n",
    "\n",
    "    def __init__(self, total_nodes = 100, anchor_percent = 0.20, t_range = 25):\n",
    "        self.total_nodes = total_nodes\n",
    "        self.anchor_percent = anchor_percent\n",
    "        self.t_range = t_range\n",
    "        self.M = int(self.anchor_percent * self.total_nodes) # no. of anchor nodes\n",
    "        self.N = self.total_nodes - self.M # no. of unknown nodes        \n",
    "        \n",
    "        # Anchor Deployment\n",
    "        for i in range(self.M):\n",
    "            x_anchor = np.random.randint(self.X_max)\n",
    "            y_anchor = np.random.randint(self.X_max)\n",
    "            self.X_anchor.append([x_anchor, y_anchor])\n",
    "        \n",
    "        # Unknown Nodes Deployment\n",
    "        for i in range(self.N):\n",
    "            x_unknown = np.random.randint(self.X_max)\n",
    "            y_unknown = np.random.randint(self.X_max)\n",
    "            self.X_unknown.append([x_unknown, y_unknown])\n",
    "        \n",
    "        self.X_unknown = np.array(self.X_unknown)\n",
    "        self.X_anchor = np.array(self.X_anchor)\n",
    "    \n",
    "        # Backup of original coordinates of Anchor and Unknown nodes\n",
    "        self.X_anchor_og = self.X_anchor.copy()\n",
    "        self.X_unknown_og = self.X_unknown.copy()\n",
    "    \n",
    "    \n",
    "    def show_field(self, unk = True):\n",
    "        \"\"\"Plots the test field containing labeled nodes\"\"\"\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        if unk == True:\n",
    "            if len(self.X_unknown) != 0:\n",
    "                plt.plot(self.X_unknown[:, 0], self.X_unknown[:, 1], 'yo', label=\"Left Node\")\n",
    "            plt.plot(self.X_unknown_og[:, 0], self.X_unknown_og[:, 1], 'ro', label='Unknown Node')\n",
    "        else:\n",
    "            plt.plot(self.X_unknown_og[:, 0], self.X_unknown_og[:, 1], 'ro', label='Unknown Node')\n",
    "            if len(self.X_unknown) != 0:\n",
    "                plt.plot(self.X_unknown[:, 0], self.X_unknown[:, 1], 'yo', label=\"Left Node\")\n",
    "        plt.plot(self.X_anchor_og[:, 0], self.X_anchor_og[:, 1], 'go', label=\"Anchor Node\")\n",
    "        plt.plot(self.X_anchor[self.M:, 0], self.X_anchor[self.M:, 1], 'b^', label=\"Localized Node\", fillstyle='none', markersize=10)\n",
    "        \n",
    "        plt.legend()\n",
    "        plt.axis([0,self.X_max,0,self.X_max])\n",
    "        plt.grid()\n",
    "        plt.show()\n",
    "    \n",
    "    \n",
    "    def alpha(self, n_iter):\n",
    "        \"\"\"Step size used in Le'vy flight\"\"\"\n",
    "        return self.alpha_max - ((n_iter/ self.N_itertotal) * (self.alpha_max - self.alpha_min)) # returns step size value\n",
    "\n",
    "    def levy(self):\n",
    "        \"\"\"Returns random walk value\"\"\"\n",
    "        temp = np.power(((gamma_function(1 + self.lamda) * np.sin(np.pi * (self.lamda /2))) / (gamma_function((1 + self.lamda)/2) * self.lamda * np.power(2, ((self.lamda - 1)/2)) )), 1/self.lamda)\n",
    "        u = np.random.normal(0, temp)\n",
    "        v = np.random.normal(0,1)\n",
    "        r = u / (np.power(abs(v), (1/self.lamda)))\n",
    "\n",
    "        return r  # random walk value\n",
    "\n",
    "    \n",
    "    def limiter(self, point):\n",
    "        \"\"\"Prevents the node from exiting the test field\"\"\"\n",
    "        x = point[0]\n",
    "        y = point[1]\n",
    "        if x > self.X_max and y > self.X_max:\n",
    "            x,y = self.X_max, self.X_max\n",
    "        elif x > self.X_max and self.X_min < y < self.X_max:\n",
    "            x,y = self.X_max, y\n",
    "        elif x > self.X_max and y < self.X_min:\n",
    "            x,y = self.X_max, self.X_min\n",
    "        elif self.X_min < x < self.X_max and y < self.X_min:\n",
    "            x,y = x, self.X_min\n",
    "        elif x < self.X_min and y < self.X_min:\n",
    "            x,y = self.X_min, self.X_min\n",
    "        elif x < self.X_min and self.X_min < y < self.X_max:\n",
    "            x,y = self.X_min, y\n",
    "        elif x < self.X_min and y > self.X_max:\n",
    "            x,y = self.X_min, self.X_max\n",
    "        elif self.X_min < x < self.X_max and y > self.X_max:\n",
    "            x,y = x, self.X_max\n",
    "\n",
    "        return [x,y]\n",
    "\n",
    "    \n",
    "    def neighbours(self, node, anchors):\n",
    "        \"\"\"Returns a list of neighbouring anchor nodes within transmission range of the input node\"\"\"\n",
    "        x = node[0]\n",
    "        y = node[1]\n",
    "        X_anchor = anchors\n",
    "                \n",
    "        l = []\n",
    "        for j in range(len(X_anchor)): # for every anchor node in the list\n",
    "            dist_real = np.power((np.power((x - X_anchor[j][0]), 2) + np.power((y - X_anchor[j][1]), 2)), 0.5)\n",
    "            np.random.seed(2)\n",
    "            dist_err = dist_real + np.random.normal(0, (self.gamma*dist_real))\n",
    "            np.random.seed()\n",
    "            \n",
    "\n",
    "            if dist_err < self.t_range: # vicinity check\n",
    "                l.append(X_anchor[j])\n",
    "                \n",
    "        return l # neighbouring anchors coordinates\n",
    "\n",
    "    def objective(self, node, n_anchors, node_unknown, min_nodes = 3):\n",
    "        \"\"\"Objective function MSE (to minimize)\"\"\"\n",
    "        x = node[0]\n",
    "        y = node[1]\n",
    "        \n",
    "        x1 = node_unknown[0]\n",
    "        y1 = node_unknown[1]\n",
    "        \n",
    "        l = self.neighbours(node_unknown, n_anchors) # calculating neighbours of the unknown node\n",
    "        m = len(l)\n",
    "        rerror = []\n",
    "        if len(l) >= min_nodes:\n",
    "            for ancn in l: \n",
    "                #dij (real distance between estimated node and anchor)\n",
    "                dist_real = np.power((np.power((x - ancn[0]), 2) + np.power((y - ancn[1]), 2)), 0.5)\n",
    "                \n",
    "                #dij1 (real distance between unknown node and anchor)\n",
    "                dist_real1 = np.power((np.power((x1 - ancn[0]), 2) + np.power((y1 - ancn[1]), 2)), 0.5)\n",
    "                \n",
    "                #dij' (calculated distance between unknown node and anchor) (includes the ranging error)\n",
    "                np.random.seed(2)\n",
    "                dist_err = dist_real1 + np.random.normal(0, (self.gamma*dist_real1))\n",
    "                np.random.seed()\n",
    "                rerror.append(np.power(dist_real - dist_err,2))\n",
    "\n",
    "        # returning worst solutions (not enough neighbouring anchors) with infinite value\n",
    "        ans = None\n",
    "        if math.isnan(np.sum(rerror)/m): \n",
    "            ans = np.inf\n",
    "        else:\n",
    "            ans = np.sum(rerror)/m or None\n",
    "            \n",
    "        return ans # mean of square of ranging error\n",
    "\n",
    "    \n",
    "    def ecs(self, N_anchor, node_unknown):\n",
    "        \"\"\"Enhanced Cuckoo Search Algorithm\"\"\"\n",
    "        # Initial population (Random deployment of 'N' nests)\n",
    "        X_nest = []                   # list of candidate solutions\n",
    "        min_nodes = len(N_anchor)     # no. of neighbouring anchors\n",
    "        for i in range(self.N_nest):\n",
    "            x_nest = np.random.randint(self.X_max)\n",
    "            y_nest = np.random.randint(self.X_max)\n",
    "            X_nest.append([x_nest, y_nest])\n",
    "        \n",
    "        # Calculating fitness value of each nest\n",
    "        Obj_X_nest = []              # list of fitness values of the candidate solutions\n",
    "        for i in range(len(X_nest)):\n",
    "            Obj_X_nest.append(self.objective(X_nest[i], N_anchor, node_unknown, min_nodes) or np.inf)\n",
    "#         print(Obj_X_nest)\n",
    "        \n",
    "        N_iter = 0                   # iteration counter\n",
    "        fmins = []                   # list of best fitness value of each iteration\n",
    "        while(N_iter < self.N_itertotal): # fittest solution search loop\n",
    "            N_iter += 1              # increment in iteration counter\n",
    "            X_js = []                # list of new candidate solutions\n",
    "            Obj_X_js = []            # list of fitness values of the new candidate solutions\n",
    "            # Applying Le'vy flight to every solution\n",
    "            for i in range(len(X_nest)):\n",
    "                X_j = X_nest[i].copy()\n",
    "                X_j[0] = X_j[0] + self.alpha(N_iter) * self.levy()\n",
    "                X_j[1] = X_j[1] + self.alpha(N_iter) * self.levy()\n",
    "                \n",
    "                X_j = self.limiter(X_j)     # limit test on new solution generated by Le'vy flight\n",
    "                \n",
    "                F_j = self.objective(X_j, N_anchor, node_unknown, min_nodes) or np.inf\n",
    "                rand_k = np.random.randint(0, len(X_nest))\n",
    "                F_k = Obj_X_nest[rand_k]\n",
    "                \n",
    "                # Comparing fitness of new solution with existing solution\n",
    "                if F_j > F_k:\n",
    "                    X_j[0] = X_nest[rand_k][0]\n",
    "                    X_j[1] = X_nest[rand_k][1]\n",
    "                    F_j = F_k\n",
    "\n",
    "                X_js.append(X_j)\n",
    "                Obj_X_js.append(F_j)\n",
    "            \n",
    "            # Finding current best solution out of 'N' nests\n",
    "            Obj_X_js = np.array([np.inf if i is None else i for i in Obj_X_js])\n",
    "            F_min = Obj_X_js[np.argmin(Obj_X_js)]\n",
    "#             print(F_min)\n",
    "            current_best_sol = X_js[np.argmin(Obj_X_js)]\n",
    "            \n",
    "            # Calculation of mutation probability (Pa)\n",
    "            Pa_j = []                 # list of mutation probabilities of all the updated candidate solutions\n",
    "            for i in Obj_X_js:\n",
    "                K = i - F_min\n",
    "                if K < 1:\n",
    "                    Pa_j.append(self.pa_min + (self.pa_max - self.pa_min) * K)\n",
    "                else:\n",
    "                    Pa_j.append(self.pa_max / N_iter)\n",
    "\n",
    "            # Mutation process\n",
    "            for i in range(len(Pa_j)):\n",
    "                rand_temp = np.random.uniform(0, 1)\n",
    "                if rand_temp < Pa_j[i]:\n",
    "                    my_x = np.random.randint(self.X_max)\n",
    "                    my_y = np.random.randint(self.X_max)\n",
    "                    F_my_xy = self.objective([my_x, my_y], N_anchor, node_unknown, min_nodes) or np.inf\n",
    "                    if (Obj_X_js[i]) > (F_my_xy):\n",
    "                        X_js[i] = [my_x, my_y]\n",
    "                        Obj_X_js[i] = F_my_xy\n",
    "            \n",
    "            # Finding the best solution of current iteration\n",
    "            Obj_X_js = np.array([np.inf if i is None else i for i in Obj_X_js])\n",
    "            F_min = Obj_X_js[np.argmin(Obj_X_js)]\n",
    "#             print(F_min)\n",
    "            self.F_mins.append(F_min)\n",
    "            fmins.append(F_min)\n",
    "            \n",
    "            # Early stopping mechanism\n",
    "            if len(fmins) > 3:\n",
    "                d1 = abs(fmins[-1] - fmins[-2])\n",
    "                d2 = abs(fmins[-2] - fmins[-3])\n",
    "                d3 = abs(fmins[-3] - fmins[-4])\n",
    "                if d1 == d2 == d3 == 0:\n",
    "#                     print('Exiting', N_iter)\n",
    "                    break\n",
    "            \n",
    "            # Obtaining the coordinates of best fit solution of the iteration\n",
    "            best_sol = X_js[np.argmin(Obj_X_js)]\n",
    "            X_nest = X_js.copy()\n",
    "            Obj_X_nest = Obj_X_js.copy()\n",
    "        \n",
    "        return best_sol # returns the coordinates of the solution with global best fitness\n",
    "                \n",
    "    \n",
    "    def update_Unknown(self, indexes):        \n",
    "        \"\"\"Updating Unknown List after localization\"\"\"\n",
    "        # append the corresponding coordinates of the index values which are not localized in a list,\n",
    "        # and then update the unknown nodes' list\n",
    "        X_unknown_temp = []\n",
    "        for j in range(len(self.X_unknown)):\n",
    "            if j in indexes:\n",
    "                pass\n",
    "            else:\n",
    "                X_unknown_temp.append(self.X_unknown[j])\n",
    "\n",
    "        self.X_unknown = np.array(X_unknown_temp)\n",
    "        \n",
    "\n",
    "    def main(self):\n",
    "        \"\"\"Node Localization Process\"\"\"\n",
    "        for j in range(5):\n",
    "            localised_indexes = []\n",
    "            for i in range(len(self.X_unknown)):\n",
    "                nn = self.neighbours(self.X_unknown[i], self.X_anchor)\n",
    "    #                 print(i, end=\"\\r\")\n",
    "                if len(nn) >= 3:\n",
    "                    updated_node_location = self.ecs(nn, self.X_unknown[i])\n",
    "\n",
    "                    self.X_loc.append([updated_node_location, self.X_unknown[i]])\n",
    "\n",
    "                    # Updated \n",
    "                    X_anchor_temp = list(self.X_anchor)\n",
    "                    X_anchor_temp.append(updated_node_location)\n",
    "                    self.X_anchor = np.array(X_anchor_temp)\n",
    "\n",
    "                    localised_indexes.append(i)\n",
    "\n",
    "            self.update_Unknown(localised_indexes)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# EXPERIMENT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "coco = Cuckoo(total_nodes=300, anchor_percent=0.45, t_range=25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting the test field\n",
    "coco.show_field()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# main function call\n",
    "start = time.time()\n",
    "coco.main()\n",
    "stop = time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ALE =  0.5598234767715047\n"
     ]
    }
   ],
   "source": [
    "# Average Localization Error (ALE)\n",
    "distances = []\n",
    "for loc in coco.X_loc:\n",
    "    modified = loc[0]\n",
    "    original = loc[1]\n",
    "    \n",
    "    distances.append(np.sqrt((modified[0] - original[0])**2 + (modified[1] - original[1])**2))\n",
    "\n",
    "ale = np.sum(distances)/len(distances)\n",
    "print('ALE = ', ale)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LSR =  100.0 %\n",
      "No.of localized nodes =  165\n"
     ]
    }
   ],
   "source": [
    "# Localization Success Ratio (LSR)\n",
    "lsr = (len(distances)/len(coco.X_unknown_og)) * 100\n",
    "print('LSR = ', lsr,'%')\n",
    "print('No.of localized nodes = ', len(distances))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No. of iterations =  3932\n"
     ]
    }
   ],
   "source": [
    "# No. of iterations required to localize all the localizable nodes\n",
    "niter = len(coco.F_mins)\n",
    "print('No. of iterations = ', niter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_time =  3366.8202843666077\n"
     ]
    }
   ],
   "source": [
    "# Total time taken (To localize all localizable nodes)\n",
    "n_time = stop-start\n",
    "print(\"n_time = \", n_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting the test field\n",
    "coco.show_field(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}