Neural Network Weight Optimisation using ACO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3c63bd0e",
   "metadata": {},
   "source": [
    "# Neural Network Weight Optimisation Using Ant Colony Optimisation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc54da31",
   "metadata": {},
   "source": [
    "## Importing necessary libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c176c63b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-04-05 14:09:09.027987: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-04-05 14:09:09.554670: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "import sklearn\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import Sequential\n",
    "from sklearn.model_selection import train_test_split\n",
    "from keras.utils import np_utils\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f764d57d",
   "metadata": {},
   "source": [
    "## Creating a neural network using tensorflow keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "b6454a88",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Sequential([tf.keras.layers.Dense(12,input_shape = (12,),activation = 'relu'),\n",
    "                    tf.keras.layers.Dense(8,activation = 'relu'),\n",
    "                    tf.keras.layers.Dense(16, activation = 'relu'),\n",
    "                    tf.keras.layers.Dense(8,activation = 'relu'),\n",
    "                    tf.keras.layers.Dense(2,activation = 'softmax')\n",
    "                   ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "23d843e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer = 'adam', metrics = ['accuracy'],loss = 'categorical_crossentropy')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "616208af",
   "metadata": {},
   "source": [
    "## Reading the dataset and splitting it into train and test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0ec14216",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('processed_data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f8a56de6",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.drop('Unnamed: 0',axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7cc105ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.get_dummies(df,columns = ['Education'],drop_first = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "50efb971",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df.drop('target',axis = 1)\n",
    "y = df['target']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a0a927c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X.values, y.values, \n",
    "                                                    test_size=0.33, \n",
    "                                                    random_state=42,\n",
    "                                                    shuffle = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4d37de7",
   "metadata": {},
   "source": [
    "### Converting target into categorical data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a52fda75",
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train=np_utils.to_categorical(y_train,num_classes=2)\n",
    "y_test=np_utils.to_categorical(y_test,num_classes=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cebe03e4",
   "metadata": {},
   "source": [
    "## Setting up some variables required for the ant colony algorithms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "66538ea8",
   "metadata": {},
   "outputs": [],
   "source": [
    "weights_shapes = [w.shape for w in model.get_weights()]\n",
    "\n",
    "# Compute the total number of weights\n",
    "num_weights = np.sum([np.prod(s) for s in weights_shapes])\n",
    "\n",
    "l = num_weights"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f60dae0",
   "metadata": {},
   "source": [
    "l = nh(ni + 1) + no(nh + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "c185925b",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "0581f476",
   "metadata": {},
   "outputs": [],
   "source": [
    "w_min = -1\n",
    "w_max = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "87b1b3d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "a_matrix = np.random.uniform(low = w_min, high = w_max,size = (v,l)) #functions as the graph for ants to traverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "d187a817",
   "metadata": {},
   "outputs": [],
   "source": [
    "t_matrix = np.ones((v,l)) #functions as the pheromone matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "31a9c3fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def roulette_wheel_selection(prob_list): #for the ants to choose a point based on the probabilities of choosing the next point\n",
    "    \"\"\"\n",
    "    Selects an index from the given list of probabilities using roulette wheel selection.\n",
    "    \n",
    "    Args:\n",
    "    prob_list: A list of non-negative floating point numbers representing probabilities.\n",
    "    \n",
    "    Returns:\n",
    "    An integer representing the index selected.\n",
    "    \"\"\"\n",
    "    # Compute the cumulative sum of probabilities\n",
    "    cum_prob = np.cumsum(prob_list)\n",
    "    \n",
    "    # Generate a random number between 0 and the sum of probabilities\n",
    "    rand_num = random.uniform(0, cum_prob[-1])\n",
    "    \n",
    "    # Find the index whose probability range encompasses the random number\n",
    "    index = np.searchsorted(cum_prob, rand_num)\n",
    "    \n",
    "    return index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "71e0dc78",
   "metadata": {},
   "outputs": [],
   "source": [
    "def choose_discrete_point(v,weight_idx): #creates the probabilities for choosing the point and chooses a point based on rws, returns the index of chosen point\n",
    "    probabilities = []\n",
    "    for point in range(v):\n",
    "        prob = t_matrix[point][weight_idx]/t_matrix.sum(axis = 0)[weight_idx] #formula from research paper\n",
    "        probabilities.append(prob)\n",
    "    idx_of_selected_point = roulette_wheel_selection(probabilities)\n",
    "    return (idx_of_selected_point)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "3f57ae5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def release_ants(number_of_ants,l,v): # creates a path for each ant and returns the list of paths\n",
    "    ant_paths = list()\n",
    "    for i in range(number_of_ants):\n",
    "        path = list()\n",
    "        for weight_idx in range(l):\n",
    "            discrete_point = choose_discrete_point(v,weight_idx)\n",
    "            path.append(discrete_point)\n",
    "            #print(path)\n",
    "        ant_paths.append(path)\n",
    "    return ant_paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "db740555",
   "metadata": {},
   "outputs": [],
   "source": [
    "def trace_path(number_of_ants,ant_paths,a_matrix,model): #based on the path traversed by ant, selects weights from a_matrix and sets it to the model and evaluated the model \n",
    "    errors = []\n",
    "    accuracies = []\n",
    "    for i in range (number_of_ants):\n",
    "        point_indices = ant_paths[i]\n",
    "        weights = []\n",
    "        for weight, point in enumerate(point_indices):\n",
    "            weights.append(a_matrix[point][weight])\n",
    "        reshaped_weights = reshape_weights(weights, model)\n",
    "        model.set_weights(weights = reshaped_weights)\n",
    "        error,accuracy = model.evaluate(X_train,y_train)\n",
    "        errors.append(error)\n",
    "        accuracies.append(accuracy)\n",
    "        \n",
    "    return errors,accuracies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "1620b53b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def retrace(errors,number_of_ants,ant_paths,t_matrix): #deposits pheromones to the path chosen by ant. the amount of pheromone deposited is calculated based on the error generated by the ant.\n",
    "    for i in range (number_of_ants):\n",
    "        delta_ph = 1/errors[i]\n",
    "        path = ant_paths[i]\n",
    "        for weight,idx in enumerate(path):\n",
    "            t_matrix[idx][weight] += delta_ph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "3443fd30",
   "metadata": {},
   "outputs": [],
   "source": [
    "def decay(t_matrix, rate): #decays the pheromone matrix to prevent propogation of mistakes made in the past\n",
    "    decayed = t_matrix * (1 - rate)\n",
    "    return np.where(decayed < 0, 0, decayed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "560742c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def reshape_weights(weights, model): #takes an array of weights and reshapes it so that it can be used in set_weights function\n",
    "    \"\"\"\n",
    "    Reshapes the weights from a 1D array to the shape required by a Keras model.\n",
    "    \n",
    "    Args:\n",
    "    weights: A 1D array of weights.\n",
    "    model: A Keras model whose weights are to be reshaped.\n",
    "    \n",
    "    Returns:\n",
    "    A list of Numpy arrays containing the reshaped weights.\n",
    "    \"\"\"\n",
    "    flattened_weights = np.array(weights)\n",
    "    weights_shapes = [w.shape for w in model.get_weights()]\n",
    "\n",
    "    # Compute the total number of weights\n",
    "    num_weights = np.sum([np.prod(s) for s in weights_shapes])\n",
    "\n",
    "    flattened_weights = np.array(weights)\n",
    "    # Check that the total number of weights matches the length of the flattened list\n",
    "    assert num_weights == len(flattened_weights)\n",
    "\n",
    "    # Reshape the flattened list into a list of weight tensors with the same shapes as the model's weights\n",
    "    weight_tensors = []\n",
    "    idx = 0\n",
    "    for shape in weights_shapes:\n",
    "        size = np.prod(shape)\n",
    "        weight_flat = flattened_weights[idx:idx+size]\n",
    "        weight = tf.constant(np.array(weight_flat).reshape(shape))\n",
    "        weight_tensors.append(weight)\n",
    "        idx += size\n",
    "    \n",
    "    return weight_tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "dc476d7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def aco(number_of_ants, l, v, t_matrix, model): \n",
    "    \"\"\"\"\n",
    "    step 1: release ants - each ant chooses a value for each weight based on the given formula for probability for\n",
    "            choosing a point and roulette wheel selection\n",
    "    step 2: trace path - for each ant, set model weights and calculate errors \n",
    "    step 3: retrace - for each ant, calculate the pheromone to be deposited and add it to every point visited by it\n",
    "    step 4: decay the whole pheromone matrix\n",
    "    step 5: repeat the whole thing until convergence\n",
    "    \"\"\"   \n",
    "    ant_paths  = release_ants(number_of_ants,l,v)\n",
    "    errors,accuracies = trace_path(number_of_ants,ant_paths,a_matrix,model)\n",
    "    retrace(errors, number_of_ants, ant_paths,t_matrix)\n",
    "    t_matrix = decay(t_matrix, 0.1)\n",
    "    return errors,accuracies,ant_paths\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "94f9afcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_best_weights(accuracies,model,ant_paths): #sets the best weight based on the ant which gives the model with the highest accuracy\n",
    "    best_path_idx = accuracies.index(max(accuracies))\n",
    "    best_path = ant_paths[best_path_idx]\n",
    "    weights = []\n",
    "    for weight, idx in enumerate(best_path):\n",
    "        weights.append(a_matrix[idx][weight])\n",
    "    flattened_weights = np.array(weights)\n",
    "    weights_shapes = [w.shape for w in model.get_weights()]\n",
    "\n",
    "    # Compute the total number of weights\n",
    "    num_weights = np.sum([np.prod(s) for s in weights_shapes])\n",
    "    flattened_weights = np.array(weights)\n",
    "    \n",
    "    assert num_weights == len(flattened_weights)\n",
    "\n",
    "    # Reshape the flattened list into a list of weight tensors with the same shapes as the model's weights\n",
    "    weight_tensors = []\n",
    "    idx = 0\n",
    "    for shape in weights_shapes:\n",
    "        size = np.prod(shape)\n",
    "        weight_flat = flattened_weights[idx:idx+size]\n",
    "        weight = tf.constant(np.array(weight_flat).reshape(shape))\n",
    "        weight_tensors.append(weight)\n",
    "        idx += size\n",
    "    model.set_weights(weight_tensors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "150a938c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step: 0\n",
      "92/92 [==============================] - 0s 443us/step - loss: 7.7702 - accuracy: 0.0634\n",
      "92/92 [==============================] - 0s 438us/step - loss: 3.5702 - accuracy: 0.8767\n",
      "92/92 [==============================] - 0s 441us/step - loss: 470.7214 - accuracy: 0.0634\n",
      "92/92 [==============================] - 0s 424us/step - loss: 483.0073 - accuracy: 0.0634\n",
      "92/92 [==============================] - 0s 444us/step - loss: 131.8449 - accuracy: 0.9366\n",
      "Step: 1\n",
      "92/92 [==============================] - 0s 428us/step - loss: 15.5817 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 439us/step - loss: 29.8635 - accuracy: 0.6050\n",
      "92/92 [==============================] - 0s 441us/step - loss: 3.4584 - accuracy: 0.8941\n",
      "92/92 [==============================] - 0s 427us/step - loss: 360.1884 - accuracy: 0.0634\n",
      "92/92 [==============================] - 0s 429us/step - loss: 44.0643 - accuracy: 0.6036\n",
      "Step: 2\n",
      "92/92 [==============================] - 0s 429us/step - loss: 25.4031 - accuracy: 0.4217\n",
      "92/92 [==============================] - 0s 438us/step - loss: 203.6668 - accuracy: 0.0634\n",
      "92/92 [==============================] - 0s 447us/step - loss: 15.2026 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 438us/step - loss: 23.3065 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 445us/step - loss: 62.7310 - accuracy: 0.9366\n",
      "Step: 3\n",
      "92/92 [==============================] - 0s 434us/step - loss: 22.9531 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 456us/step - loss: 37.6695 - accuracy: 0.5567\n",
      "92/92 [==============================] - 0s 476us/step - loss: 189.9682 - accuracy: 0.0634\n",
      "92/92 [==============================] - 0s 463us/step - loss: 3.8909 - accuracy: 0.8167\n",
      "92/92 [==============================] - 0s 441us/step - loss: 18.4211 - accuracy: 0.5793\n",
      "Step: 4\n",
      "92/92 [==============================] - 0s 449us/step - loss: 15.9835 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 464us/step - loss: 22.5585 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 435us/step - loss: 68.1820 - accuracy: 0.0716\n",
      "92/92 [==============================] - 0s 440us/step - loss: 163.4742 - accuracy: 0.0634\n",
      "92/92 [==============================] - 0s 442us/step - loss: 2.2014 - accuracy: 0.8287\n",
      "Step: 5\n",
      "92/92 [==============================] - 0s 484us/step - loss: 2.2265 - accuracy: 0.9325\n",
      "92/92 [==============================] - 0s 478us/step - loss: 42.5629 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 478us/step - loss: 33.8443 - accuracy: 0.8150\n",
      "92/92 [==============================] - 0s 487us/step - loss: 280.1101 - accuracy: 0.0634\n",
      "92/92 [==============================] - 0s 480us/step - loss: 15.1536 - accuracy: 0.6632\n",
      "Step: 6\n",
      "92/92 [==============================] - 0s 490us/step - loss: 45.6140 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 459us/step - loss: 11.4913 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 461us/step - loss: 62.4930 - accuracy: 0.1028\n",
      "92/92 [==============================] - 0s 475us/step - loss: 6.4691 - accuracy: 0.6029\n",
      "92/92 [==============================] - 0s 477us/step - loss: 12.8984 - accuracy: 0.5913\n",
      "Step: 7\n",
      "92/92 [==============================] - 0s 429us/step - loss: 22.5528 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 445us/step - loss: 15.4910 - accuracy: 0.9185\n",
      "92/92 [==============================] - 0s 436us/step - loss: 4.9179 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 434us/step - loss: 13.3255 - accuracy: 0.5817\n",
      "92/92 [==============================] - 0s 438us/step - loss: 288.7115 - accuracy: 0.0634\n",
      "Step: 8\n",
      "92/92 [==============================] - 0s 435us/step - loss: 34.2168 - accuracy: 0.5954\n",
      "92/92 [==============================] - 0s 453us/step - loss: 29.3471 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 427us/step - loss: 131.5051 - accuracy: 0.0637\n",
      "92/92 [==============================] - 0s 431us/step - loss: 31.8778 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 437us/step - loss: 35.2657 - accuracy: 0.9130\n",
      "Step: 9\n",
      "92/92 [==============================] - 0s 462us/step - loss: 31.2900 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 477us/step - loss: 35.7902 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 445us/step - loss: 28.3956 - accuracy: 0.2850\n",
      "92/92 [==============================] - 0s 441us/step - loss: 37.1402 - accuracy: 0.9366\n",
      "92/92 [==============================] - 0s 451us/step - loss: 38.8399 - accuracy: 0.9366\n"
     ]
    }
   ],
   "source": [
    "number_of_ants = 5\n",
    "for i in range(10):\n",
    "    print('Step:',i)\n",
    "    errors,accuracies,ant_paths = aco(number_of_ants, l, v, t_matrix, model)\n",
    "set_best_weights(accuracies,model,ant_paths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "39bd6a4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45/45 [==============================] - 0s 496us/step - loss: 27.5587 - accuracy: 0.9437\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[27.558746337890625, 0.9437109231948853]"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(X_test, y_test)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:tf_gpu]",
   "language": "python",
   "name": "conda-env-tf_gpu-py"
  },
  "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.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}