BBA_LAHC.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import math\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = pd.read_csv('LPC.csv')\n",
    "X = dataset.iloc[:, :-1].values\n",
    "y = dataset.iloc[:, -1].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Initializations\n",
    "\n",
    "Max_iteration=30 #max no. of iterations\n",
    "noP = 30 #No. of artificial bats\n",
    "noV = np.size(X,1); #dimension of search variables\n",
    "A = 0.9 #Loudness\n",
    "r = 0.2 #Pulse rate\n",
    "pi = math.pi      \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "noV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define BBA\n",
    "\n",
    "def BBA(n, A, r, d, Max_iter, CostFunction):\n",
    "        \n",
    "    Qmin = 0 #min freq\n",
    "    Qmax = 2 #max freq\n",
    "    \n",
    "    N_iter = 0 #total no.  function evalutations\n",
    "    \n",
    "    #initialize arrays\n",
    "    Q = np.zeros((n,1)) #Freq\n",
    "    v = np.zeros((n,d)) #Velocities\n",
    "    S = np.zeros((n,d)) #empty solution matrix \n",
    "    #cg_curve = np.zeros((1, Max_iter)) #convergence curve which i prolly wont need\n",
    "    Sol = np.zeros((n,d))\n",
    "    Fitness=[]    \n",
    "    \n",
    "    for i in range(0,n):\n",
    "        for j in range(0,d):\n",
    "            if random.random()<=0.5:\n",
    "                Sol[i][j]=0\n",
    "            else:\n",
    "                Sol[i][j]=1\n",
    "    \n",
    "    for a in range(0,n):\n",
    "        Fitness.append(CostFunction(Sol[a,:]))\n",
    "    \n",
    "    # Find the current best\n",
    "    fmin = min(Fitness) \n",
    "    I = Fitness.index(fmin)\n",
    "    best = Sol[I,:] #I is the position of 1s\n",
    "    \n",
    "    #Start the iterations -- Binary Bat Algorithm\n",
    "    while(N_iter<Max_iter):\n",
    "        N_iter += 1\n",
    "       # cg_curve[N_iter] = fmin\n",
    "        for i in range(0,n):\n",
    "            for j in range(0,d):\n",
    "                Q[i] = Qmin+(Qmin+Qmax)*random.random() #Eq 3 in paper\n",
    "                v[i,j] = v[i,j] + (Sol[i,j]-best[j])*Q[i] #Eq 1 in paper\n",
    "                V_shaped_transfer_function=abs((2/pi)*math.atan((pi/2)*v[i,j])); #Eq 9 in the paper\n",
    "                \n",
    "                \n",
    "                if random.random()<V_shaped_transfer_function: #Eq 10 in the paper\n",
    "                    S[i,j]=int(not S[i,j]) \n",
    "                if random.random()>r:\n",
    "                    S[i,j]=best[j]\n",
    "             \n",
    "            Fnew = CostFunction(Sol[i,:])\n",
    "            \n",
    "            if (Fnew<=Fitness[i] and random.random()<A): #solution improves and not too loud\n",
    "                Sol[i,:] = S[i,:]\n",
    "                Fitness[i] = Fnew\n",
    "            \n",
    "            #Update current best\n",
    "            if Fnew <= fmin:\n",
    "                best = S[i,:]\n",
    "                fmin = Fnew\n",
    "                \n",
    "            #LAHC Local Search\n",
    "            \n",
    "            Best = LAHC(CostFunction , d ,best)\n",
    "            \n",
    "            \n",
    "            \n",
    "    \n",
    "    #Output\n",
    "    print(\"Number of evaluations : \", str(N_iter))\n",
    "    print(\" fmin=\", str(fmin))\n",
    "    return [Best,fmin]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define LAHC\n",
    "def LAHC(CostFunction, d, Candidate):\n",
    "    \n",
    "    Lfa = 10\n",
    "    s = [random.randint(0, 1) for i in range(d)] # initial solution is produced\n",
    "    \n",
    "    Cs = CostFunction(s) # cost of solution\n",
    "    best = s # best solution\n",
    "    #Cbest = Cs # cost of best solution\n",
    "    f = Cs * np.ones(Lfa) # If Lfa is large, an array will be more efficient than a list\n",
    "    I = 0\n",
    "    I_idle=0\n",
    "                \n",
    "    while (I<100000) and (I_idle>I*0.02):\n",
    "                    \n",
    "        candidate_sol = Candidate # Sol[i,:]\n",
    "        candidate_cost = CostFunction(candidate_sol) # cost function for the candidate\n",
    "                    \n",
    "        if candidate_cost >= Cs:    \n",
    "            I_idle = I_idle + 1\n",
    "        else:   \n",
    "            I_idle = 0\n",
    "                        \n",
    "        v = I % Lfa\n",
    "                    \n",
    "        if candidate_cost <= f[v] or candidate_cost <= Cs: # accept the candidate\n",
    "            s = candidate_sol\n",
    "        else:\n",
    "            pass # reject the candidate\n",
    "                    \n",
    "        if Cs < f[v]:\n",
    "            f[v] = Cs\n",
    "                    \n",
    "        I = I + 1\n",
    "                    \n",
    "    return best\n",
    "                \n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Define cost func\n",
    "def CostFunction(solution): #1 X d wala matrix\n",
    "    np_sol = np.asarray(solution) #np_sol is an 1 X d array \n",
    "    for elements in np_sol:\n",
    "        no_of_zeroes = np.count_nonzero(elements==0)\n",
    "    \n",
    "    unselected_features = no_of_zeroes/noV\n",
    "    \n",
    "    # Importing the dataset\n",
    "    dataset = pd.read_csv('merged_mfcc_lpc_IITM900.csv')\n",
    "    X = dataset.iloc[:, :-1].values\n",
    "    y = dataset.iloc[:, -1].values\n",
    "    # Splitting the dataset into the Training set and Test set\n",
    "    from sklearn.model_selection import train_test_split\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)\n",
    "    \n",
    "    #from X_train take only those values corresponding to 1\n",
    "    list1 = np.nonzero(np_sol)\n",
    "    indices=[]\n",
    "    for i in range(0,len(list1[0])):\n",
    "        indices.append(list1[0][i])\n",
    "    \n",
    "    X_train_new=X_train[:,indices]\n",
    "    X_test_new=X_test[:,indices]\n",
    "    \n",
    "    # Feature Scaling\n",
    "    from sklearn.preprocessing import StandardScaler\n",
    "    sc = StandardScaler()\n",
    "    X_train_new = sc.fit_transform(X_train_new)\n",
    "    X_test_new = sc.transform(X_test_new)\n",
    "    \n",
    "    \n",
    "    # Training the Kernel SVM model on the Training set\n",
    "    from sklearn.ensemble import RandomForestClassifier\n",
    "    classifier = RandomForestClassifier(n_jobs = -1, verbose = 0, n_estimators=50, criterion='entropy', random_state = 0)\n",
    "    classifier.fit(X_train_new, y_train)\n",
    "\n",
    "    # Predicting the Test set results\n",
    "    y_pred = classifier.predict(X_test_new)\n",
    "    \n",
    "    from sklearn.metrics import accuracy_score\n",
    "    from sklearn.metrics import classification_report\n",
    "\n",
    "    accuracy = accuracy_score(y_test,y_pred)\n",
    "    \n",
    "    \n",
    "    alpha=0.9\n",
    "    return -(alpha*accuracy+(1-alpha)*unselected_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "gbest = BBA(noP, A, r, noV, Max_iteration, CostFunction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(gbest[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indices1=[]\n",
    "for i in range(0,len(gbest[0])):\n",
    "    indices1.append(gbest[0][i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "List = []\n",
    "\n",
    "for i in range(0,len(gbest[0])):\n",
    "    if gbest[0][i] == 1:\n",
    "        List.append(i)\n",
    "        \n",
    "df_train = pd.read_csv(\"merged_mfcc_lpc_IITM900.csv\")\n",
    "y = (df_train['label'])\n",
    "df_train1 = df_train[df_train.columns[List]]\n",
    "l = []\n",
    "for i in range(0,len(List)):\n",
    "    l.append(i)\n",
    "    \n",
    "df_train1.columns = l\n",
    "\n",
    "df_train1['label'] = y\n",
    "df_train1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train1.to_csv('merged_mfcc_lpc_IITM900_BBALAHC.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}