ecs-code-exp1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": [
    "file1 = open(\"ecs-ale200-anc50.txt\", \"a\")\n",
    "file2 = open(\"ecs-lsr200-anc50.txt\", \"a\")\n",
    "file3 = open(\"ecs-nloc200-anc50.txt\", \"a\")\n",
    "file4 = open(\"ecs-et200-anc50.txt\", \"a\")\n",
    "\n",
    "ecs_ales = []\n",
    "ecs_lsrs = []\n",
    "ecs_nlocs = []\n",
    "ecs_ets = []\n",
    "\n",
    "for p in range (30):\n",
    "    class Cuckoo():\n",
    "\n",
    "        # Constant Parameters\n",
    "        X_min = 0\n",
    "        X_max = 100\n",
    "        alpha_min = 0.9\n",
    "        alpha_max = 1.0\n",
    "        pa_min = 0.05\n",
    "        pa_max = 0.25\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\n",
    "        anchor_percent = 0\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",
    "        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 (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\n",
    "                    dist_real = np.power((np.power((x - ancn[0]), 2) + np.power((y - ancn[1]), 2)), 0.5)\n",
    "\n",
    "                    #dij1\n",
    "                    dist_real1 = np.power((np.power((x1 - ancn[0]), 2) + np.power((y1 - ancn[1]), 2)), 0.5)\n",
    "\n",
    "                    #dij'\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 mod_cs(self, N_anchor, node_unknown):\n",
    "            \"\"\"Enhanced Cuckoo Search Algorithm\"\"\"\n",
    "            # Initial population (Random deployment of 'N' nests)\n",
    "            X_nest = []\n",
    "            min_nodes = len(N_anchor)\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 = []\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\n",
    "            fmins = []\n",
    "            while(N_iter < self.N_itertotal): # fittest solution search loop\n",
    "                N_iter += 1\n",
    "                X_js = []\n",
    "                Obj_X_js = []\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)\n",
    "\n",
    "                    F_j = self.objective(X_j, N_anchor, node_unknown, min_nodes) or np.inf\n",
    "\n",
    "                    rand_k = np.random.randint(0, len(X_nest))\n",
    "\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 = []\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",
    "    #                 delta = 0.05\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",
    "    #                 if abs(d1 - d2) and abs(d2 - d3) and abs(d1 - d3) < delta:\n",
    "    #                     print('Exiting', N_iter)\n",
    "                        break\n",
    "\n",
    "                # Obtaining the fittest coordinates 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 global best estimated coordinates\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, 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.mod_cs(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",
    "\n",
    "    \n",
    "    # EXPERIMENT\n",
    "    start = time.time()\n",
    "    coco = Cuckoo(total_nodes=200, anchor_percent=0.5, t_range=25)\n",
    "    coco.main()\n",
    "    stop = time.time()\n",
    "    \n",
    "    # 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",
    "    s1 = str(ale)\n",
    "    file1.write(s1 + \"\\n\")\n",
    "    ecs_ales.append(ale)\n",
    "    \n",
    "    # Localization Success Ratio (LSR)\n",
    "    lsr = (len(distances)/len(coco.X_unknown_og)) * 100\n",
    "    s2 = str(lsr)\n",
    "    file2.write(s2 + \"\\n\")\n",
    "    ecs_lsrs.append(lsr)\n",
    "    \n",
    "    # No. of iterations required to localize all the localizable nodes\n",
    "    niter = len(coco.F_mins)\n",
    "    s3 = str(niter)\n",
    "    file3.write(s3 + \"\\n\")\n",
    "    ecs_nlocs.append(niter)\n",
    "    \n",
    "    # Execution Time\n",
    "    et = stop - start\n",
    "    s4 = str(et)\n",
    "    file4.write(s4 + \"\\n\")\n",
    "    ecs_ets.append(et)\n",
    "\n",
    "file1.close()\n",
    "file2.close()\n",
    "file3.close()\n",
    "file4.close()\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ecs_ales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ecs_lsrs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ecs_nlocs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ecs_ets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x170c5b0>]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(coco.F_mins)"
   ]
  },
  {
   "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
}