vaibhav_new_1_0.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "vaibhav_new_1_0.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "t_dz8E8lJ3gX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "from scipy.special import gamma as gamma_function"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vzpc2IkaP3py",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 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\n",
        "N_itertotal = 100\n",
        "\n",
        "gamma = 0.1          # noise factor\n",
        "lamda = 1.5          # constant used in le'vy flight"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "auLebkboQo7B",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# scalable parameters\n",
        "total_nodes = 100\n",
        "anchor_percent = 0.1\n",
        "M = int(anchor_percent*total_nodes) # no. of anchor nodes\n",
        "N = total_nodes - M # no. of unknown nodes\n",
        "\n",
        "t_range = 25 # transmission range"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VveTW6TOfhm1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# X_anchor = [[33,500],[1000,1000]]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ulSu6oyrgKx3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# # distance calculator\n",
        "# def dist(x1,y1,x2,y2):\n",
        "#   dist_real = np.power(np.power(x1-x2,2) + np.power(y1-y2,2),0.5)\n",
        "#   dist_err = dist_real + np.random.normal(0, gamma*dist_real)\n",
        "#   return dist_real, dist_err"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4ifq_35ZKAXF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# neighbour anchors calculator\n",
        "def neighbours(x, y):\n",
        "  l = []\n",
        "  for j in range(len(X_anchor)): # for every anchor nodes\n",
        "    dist_real = np.power((np.power((x - X_anchor[j][0]), 2) + np.power((y - X_anchor[j][1]), 2)), 0.5)\n",
        "    dist_err = dist_real + np.random.normal(0, (gamma*dist_real))\n",
        "\n",
        "    if dist_err < t_range:\n",
        "      l.append(X_anchor[j])\n",
        "  \n",
        "  # return len(l),l # returns no. of neighbouring anchors and  their coords as a tuple\n",
        "  return l # neighbouring anchors coordinates"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X3Kp-qxdfbsS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# l = neighbours(2,3)\n",
        "# print(l)\n",
        "# print(len(l))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bVLYYDOcMft8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# step size (alpha)\n",
        "def alpha(n_iter):\n",
        "  return alpha_max - ((n_iter/ N_itertotal) * (alpha_max - alpha_min)) # returns step size value\n",
        "\n",
        "# Le'vy flight function\n",
        "def levy():\n",
        "  temp = np.power(((gamma_function(1 + lamda) * np.sin(np.pi * (lamda /2))) / (gamma_function((1 + lamda)/2) * lamda * np.power(2, ((lamda - 1)/2)) )), 1/lamda)\n",
        "  u = np.random.normal(0, temp)\n",
        "  v = np.random.normal(0,1)\n",
        "  r = u / (np.power(abs(v), (1/lamda)))\n",
        "\n",
        "  return r  # random walk value\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RUHTISXRVk8Z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# location limit tester\n",
        "def limiter(x,y):\n",
        "  if x > X_max and y > X_max:\n",
        "    x,y = X_max, X_max\n",
        "    # X_j = X_rand\n",
        "  elif x > X_max and X_min < y < X_max:\n",
        "    x,y = X_max, y\n",
        "    # X_j = X_rand\n",
        "  elif x > X_max and y < X_min:\n",
        "    x,y = X_max, X_min\n",
        "    # X_j = X_rand\n",
        "  elif X_min < x < X_max and y < X_min:\n",
        "    x,y = x, X_min\n",
        "    # X_j = X_rand\n",
        "  elif x < X_min and y < X_min:\n",
        "    x,y = X_min, X_min\n",
        "    # X_j = X_rand\n",
        "  elif x < X_min and X_min < y < X_max:\n",
        "    x,y = X_min, y\n",
        "    # X_j = X_rand\n",
        "  elif x < X_min and y > X_max:\n",
        "    x,y = X_min, X_max\n",
        "    # X_j = X_rand\n",
        "  elif X_min < x < X_max and y > X_max:\n",
        "    x,y = x, X_max\n",
        "    # X_j = X_rand\n",
        "  \n",
        "  return x,y"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7dEEKJ61YB-e",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# print(limiter(0,0))\n",
        "# print(limiter(100,0))\n",
        "# print(limiter(0,100))\n",
        "# print(limiter(100,100))\n",
        "# print(limiter(22,55))\n",
        "# print(limiter(150,150))\n",
        "# print(limiter(150,25))\n",
        "# print(limiter(151,-40))\n",
        "# print(limiter(34,-60))\n",
        "# print(limiter(-32,-45))\n",
        "# print(limiter(-70,22))\n",
        "# print(limiter(-70,120))\n",
        "# print(limiter(24,155))\n",
        "\n",
        "# v = limiter(24,155)\n",
        "# v = np.array(v)\n",
        "# print(v[0])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HmSE37QzZdHU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# objective function (to minimize)\n",
        "def objective(x,y):\n",
        "  l = neighbours(x,y)\n",
        "  if len(l) >= 3:\n",
        "    m = len(l)\n",
        "    rerror = []\n",
        "    for ancn in l:\n",
        "      dist_real = np.power((np.power((x - ancn[0]), 2) + np.power((y - ancn[1]), 2)), 0.5)\n",
        "      dist_err = dist_real + np.random.normal(0, (gamma*dist_real))\n",
        "      rerror.append(np.power(dist_real - dist_err,2))\n",
        "    \n",
        "    return np.sum(rerror)/m or None # mean of square of ranging error\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IK3ppVQXIvFN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# X_anchor = [[29,68],[16,79],[45,57]]\n",
        "# neighbours(38,81)\n",
        "# v = objective(38,81)\n",
        "# print(v)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6CdtCOo9RmFH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# # average localization error (ALE)\n",
        "# def ale():\n",
        "#   ans ="
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qj75nYc4Rp7B",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# localization success ratio (LSR)\n",
        "def lsr(x,y):\n",
        "  ans = (x/y) * 100\n",
        "\n",
        "  return ans"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6a7BK54TYTY5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# modified CS algorithm (paper)\n",
        "def mod_cs():\n",
        "  X_nest = []\n",
        "\n",
        "  for i in range(N_nest):\n",
        "    x_nest = np.random.randint(100)\n",
        "    y_nest = np.random.randint(100)\n",
        "\n",
        "    X_nest.append([x_nest, y_nest])\n",
        "\n",
        "  Obj_X_nest = []\n",
        "  for i in range(len(X_nest)):\n",
        "    Obj_X_nest.append(objective(X_nest[i][0],X_nest[i][1]))\n",
        "    # print(Obj_X_nest)\n",
        "\n",
        "  N_iter = 1\n",
        "  while (N_iter < N_itertotal):\n",
        "    X_js = []\n",
        "    for i in range(len(X_nest)):\n",
        "      X_j = X_nest[i]\n",
        "      X_j[0] = X_nest[i][0] + alpha(N_iter) * levy()\n",
        "      X_j[1] = X_nest[i][1] + alpha(N_iter) * levy()\n",
        "\n",
        "      v = limiter(X_j[0],X_j[1])\n",
        "      X_j[0] = v[0]\n",
        "      X_j[1] = v[1]\n",
        "\n",
        "      F_j = objective(X_j[0],X_j[1]) or 0\n",
        "      rand_k = np.random.randint(0, len(X_nest))\n",
        "      F_k = objective(X_nest[rand_k][0], X_nest[rand_k][1]) or 0\n",
        "\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",
        "      # X_js = np.array(X_js)\n",
        "      # print(X_js)\n",
        "      # break\n",
        "\n",
        "    # Fitness values of current iteration's solutions\n",
        "    Obj_X_js = []\n",
        "    for i in range(len(X_js)):\n",
        "      Obj_X_js.append(objective(X_js[i][0], X_js[i][1]))\n",
        "    \n",
        "    # Best solution selection\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",
        "    best_sol = X_js[np.argmin(Obj_X_js)]\n",
        "\n",
        "    # Mutation probability\n",
        "    Pa_j = []\n",
        "    for i in Obj_X_js:\n",
        "      K = i - F_min\n",
        "      if K < 1:\n",
        "        Pa_j.append(pa_min + (pa_max - pa_min) * K)\n",
        "      else:\n",
        "        Pa_j.append(pa_max / N_iter)\n",
        "\n",
        "    # New random solutions generation according to mutation probability\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(100)\n",
        "        my_y = np.random.randint(100)\n",
        "        X_js[i] = [my_x, my_y]\n",
        "\n",
        "        v = limiter(X_js[i][0],X_js[i][1])\n",
        "        X_js[i][0] = v[0]\n",
        "        X_js[i][1] = v[1]\n",
        "\n",
        "        Obj_X_js[i] = objective(X_js[i][0],X_js[i][1])\n",
        "    # end for\n",
        "\n",
        "    # Rank all solutions (and find current best)\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",
        "    best_sol = X_js[np.argmin(Obj_X_js)]\n",
        "\n",
        "\n",
        "    X_js = np.array(X_js)\n",
        "    X_nest = X_js\n",
        "    # print([X_js, Obj_X_js, best_sol, X_])\n",
        "    # print(best_sol)\n",
        "    \n",
        "    N_iter += 1\n",
        "  return best_sol\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZL8_2poGPJN4",
        "colab_type": "text"
      },
      "source": [
        "### MAIN"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CCSiVFF_Iw2o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# anchor nodes random placement\n",
        "X_anchor = []\n",
        "\n",
        "for i in range(M):\n",
        "  x_anchor = np.random.randint(100)\n",
        "  y_anchor = np.random.randint(100)\n",
        "\n",
        "  X_anchor.append([x_anchor, y_anchor])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uPTpK6L7r47o",
        "colab_type": "code",
        "outputId": "f3c6b3a3-9dbf-4ab7-9ce3-a9b1658f8a04",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        }
      },
      "source": [
        "X_anchor"
      ],
      "execution_count": 118,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[89, 15],\n",
              " [45, 48],\n",
              " [4, 92],\n",
              " [49, 92],\n",
              " [48, 63],\n",
              " [87, 32],\n",
              " [76, 37],\n",
              " [62, 65],\n",
              " [58, 74],\n",
              " [23, 12]]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 118
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UpxyIPJjO-2l",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# unknown nodes random placement\n",
        "X_unknown = []\n",
        "\n",
        "for i in range(N):\n",
        "  x_unknown = np.random.randint(100)\n",
        "  y_unknown = np.random.randint(100)\n",
        "\n",
        "  X_unknown.append([x_unknown, y_unknown])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rwBgbqGIPmxH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "X_unknown = np.array(X_unknown)\n",
        "X_anchor = np.array(X_anchor)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v4m8GUQOr-YJ",
        "colab_type": "code",
        "outputId": "a182a487-9719-484c-8f0d-0f4046ebc199",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        }
      },
      "source": [
        "X_anchor"
      ],
      "execution_count": 121,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[89, 15],\n",
              "       [45, 48],\n",
              "       [ 4, 92],\n",
              "       [49, 92],\n",
              "       [48, 63],\n",
              "       [87, 32],\n",
              "       [76, 37],\n",
              "       [62, 65],\n",
              "       [58, 74],\n",
              "       [23, 12]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 121
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u1_ROuW9PvXx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# back up of original anchors and unknowns\n",
        "X_anchor_og = X_anchor.copy()\n",
        "X_unknown_og = X_unknown.copy()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RnxSpK_0P6i5",
        "colab_type": "code",
        "outputId": "e5872477-c89d-4803-fa08-91afce06ef5f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 483
        }
      },
      "source": [
        "plt.figure(figsize=(8, 8))\n",
        "plt.plot(X_unknown[:, 0], X_unknown[:, 1], 'ro', label=\"Unknown Node\")\n",
        "plt.plot(X_anchor[:, 0], X_anchor[:, 1], 'go', label=\"Anchor Node\")\n",
        "plt.legend()\n",
        "plt.grid()\n",
        "plt.show()"
      ],
      "execution_count": 123,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0OXiE6q7QASs",
        "colab_type": "code",
        "outputId": "d2d485e1-eb33-4d0d-8f3a-d959f1be94e5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "X_obj = []\n",
        "for i in range(len(X_unknown)):\n",
        "  X_obj.append(objective(X_unknown[i][0],X_unknown[i][1]))\n",
        "print(X_obj)"
      ],
      "execution_count": 124,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[None, None, 0.9894793874039154, None, 3.9072073145435313, None, None, None, None, 0.9915715687631487, None, 3.643538740693995, None, None, 1.6426528770931712, None, None, None, None, 8.937548580349898, None, None, None, None, None, None, None, None, None, None, None, None, None, 2.6677016041211337, 6.669736675644118, 2.6682898632051217, 1.7072034109541774, None, None, None, None, None, None, None, 4.761692870641565, None, None, None, None, None, None, None, None, None, 1.7889507845473558, None, None, None, 1.3971375283635894, None, None, 1.2492694334725227, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, 2.446349899276528, 1.9957157670071297, 4.391402665506692, 0.9781199633650596, None, None, None, None, None, 1.4363526011503793, None, None, None]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nqdGTrKAQpSB",
        "colab_type": "code",
        "outputId": "6ab2894a-6e43-4c77-d3de-50090023e46b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "not_possible = 0\n",
        "for i in range(len(X_obj)):\n",
        "  if X_obj[i] == None:\n",
        "    not_possible += 1\n",
        "\n",
        "print(not_possible)"
      ],
      "execution_count": 125,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "71\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zYdGtrxoSu8O",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(len(X_unknown)):\n",
        "  loc = neighbours(X_unknown[i][0],X_unknown[i][1])\n",
        "  if len(loc) >= 3:\n",
        "    X_anchor = loc\n",
        "    f_start = objective(X_unknown[i][0],X_unknown[i][1])\n",
        "\n",
        "    # call modified CS algorithm\n",
        "    v = mod_cs()\n",
        "    print(X_unknown[i])\n",
        "    print(f_start)\n",
        "    print(X_anchor)\n",
        "    print(v)\n",
        "    print(objective(v[0],v[1]))\n",
        "  \n",
        "  # localize the best solution coordinates\n",
        "  # remove the current node [i] from \"unknown list\", and add best_sol [i] to \"anchor list\"\n",
        "\n",
        "  break"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mupuIT3jx7kk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# v"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dfu7QRpapxwV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# X_unknown[i]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2awlGCDepx_l",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# print(f_start)\n",
        "# print(X_anchor)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q6zKufEWpyVK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}