Feature_Selection_862317259.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "17ee0d1d",
   "metadata": {
    "id": "17ee0d1d"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import math\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f58b6004",
   "metadata": {
    "id": "f58b6004"
   },
   "outputs": [],
   "source": [
    "# feature selection type variables\n",
    "FORWARD_SELECTION, BACKWARD_ELIMINATION = 'forward_selection', 'backward_elimination'\n",
    "\n",
    "# cache to reduce the computational cost during measurement of euclidean distance\n",
    "cache = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c78b54c7",
   "metadata": {
    "id": "c78b54c7"
   },
   "outputs": [],
   "source": [
    "# given a file path of the dataset, method reads dataset\n",
    "# and returns all the instances with their labels\n",
    "# and feature count per instance\n",
    "def read_dataset(dataset_path):\n",
    "\n",
    "    data = pd.read_csv(dataset_path, delim_whitespace=True, header = None)\n",
    "    instance_count, column_count = data.shape   \n",
    "    feature_count = column_count - 1\n",
    "    instances = data.values.tolist()\n",
    "    \n",
    "    return instances, instance_count, feature_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "324bf4ea",
   "metadata": {
    "id": "324bf4ea"
   },
   "outputs": [],
   "source": [
    "# given two instances of the dataset, and a list of features to be considered\n",
    "# method find the euclidean distance based on the features given\n",
    "# the method uses a global cache to reduce the computational cost incurred\n",
    "# to find the distance, whenever it finds two features, that are already stored\n",
    "# in the map with its squared difference, the method gets the value from the map\n",
    "# otherwise, it calculates the value and stores in the map for further usage\n",
    "def find_euclidean_distance(instance, compare_instance, features):\n",
    "    \n",
    "    squares = 0\n",
    "    # iterates over the given features\n",
    "    for feature in features:\n",
    "        \n",
    "        x = instance[feature]\n",
    "        y = compare_instance[feature]\n",
    "        val = 0\n",
    "        \n",
    "        # searching if already the calculated value is in the cache\n",
    "        if (x,y) in cache:\n",
    "            val = cache[(x, y)]\n",
    "        elif (y,x) in cache:\n",
    "            val = cache[(y, x)]\n",
    "        else:\n",
    "            diff = x - y\n",
    "            val = diff ** 2\n",
    "            \n",
    "            cache[(x, y)] = val\n",
    "            \n",
    "        squares += val\n",
    "    \n",
    "    return math.sqrt(squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6f997e96",
   "metadata": {
    "id": "6f997e96"
   },
   "outputs": [],
   "source": [
    "# given the dataset and feature set to be considered\n",
    "# method predicts the label of the instance and compares the predicted one with\n",
    "# the given label using nearest neighbor classifier where k = 1\n",
    "# method returns the ratio of count of correctly predicted instances and\n",
    "# total instances\n",
    "def find_nearest_neighbor(dataset, feature_set, instance_count):\n",
    "    \n",
    "    correct_prediction = 0\n",
    "    # iterating over each of the instance\n",
    "    for instance_idx in range(instance_count):\n",
    "        \n",
    "        # extracts the current instance\n",
    "        instance = dataset[instance_idx]\n",
    "        # extracts the label of the current instance\n",
    "        target = instance[0]\n",
    "        # the set of features to be considered\n",
    "        features = feature_set \n",
    "        \n",
    "        nearest_neighbor_distance = math.inf\n",
    "        nearest_neighbor_predict = -1\n",
    "        \n",
    "        # iterates over each of the other instances in the dataset\n",
    "        # to find which instance is more close in respect of euclidean \n",
    "        # distance\n",
    "        for compare_idx in range(instance_count):\n",
    "            \n",
    "            if compare_idx != instance_idx:\n",
    "                \n",
    "                compare_instance = dataset[compare_idx]\n",
    "                compare_target = compare_instance[0]\n",
    "                distance = find_euclidean_distance(instance,\n",
    "                                                  compare_instance,\n",
    "                                                  features)\n",
    "                \n",
    "                if distance < nearest_neighbor_distance:\n",
    "                        nearest_neighbor_distance = distance\n",
    "                        nearest_neighbor_predict = compare_target\n",
    "        \n",
    "        # checking whether the predicted label matches the target label\n",
    "        if nearest_neighbor_predict == target:\n",
    "            correct_prediction += 1\n",
    "\n",
    "    # returns the ratio of the count of correctly predicted instance and \n",
    "    # total instances    \n",
    "    return correct_prediction / instance_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f352d693",
   "metadata": {
    "id": "f352d693"
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# plots a graph to show how accuracy gets affected by feature counts\n",
    "def plot_graph(accuracy_map, search_type, dataset_size):\n",
    "    \n",
    "    x = []\n",
    "    y = []\n",
    "    for key in sorted(accuracy_map):\n",
    "        x.append(key)\n",
    "        y.append(accuracy_map[key])\n",
    "        \n",
    "    plt.plot(x, y)\n",
    "    plt.xlabel('Feature Count')\n",
    "    plt.ylabel('Accuracy')\n",
    "    plt.title('' + search_type.upper() + ' Dataset ' + dataset_size)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1ddfb41f",
   "metadata": {
    "id": "1ddfb41f"
   },
   "outputs": [],
   "source": [
    "# given the instances and feature set to be considered,\n",
    "# method iteratively leaves one instance, runs nearest neighbor classifier on\n",
    "# the remaining instances, and finds the accuracy, that is how, the number of \n",
    "# validation set will be equal to the number of instance count\n",
    "# returns the average of the accuracy over all the validation sets\n",
    "def leave_one_out_cross_validation(instances, instance_count, feature_set):\n",
    "    \n",
    "    accuracy_list = []\n",
    "    # iterates over each of the instances\n",
    "    for k_fold_itr in range(0, instance_count):\n",
    "        \n",
    "        # prepares a dataset removing k_fold_itr th instance\n",
    "        dataset = instances[ :k_fold_itr] + instances[k_fold_itr + 1: ]\n",
    "\n",
    "        # runs nearest neighbor classifier to finds accuracy \n",
    "        accuracy = find_nearest_neighbor(dataset, feature_set, \\\n",
    "                                         instance_count - 1)\n",
    "        \n",
    "        # appendds the accuracy in a list\n",
    "        accuracy_list.append(accuracy)\n",
    "    \n",
    "    # returns the average accuracy found\n",
    "    return sum(accuracy_list)/instance_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "74381ba8",
   "metadata": {
    "id": "74381ba8"
   },
   "outputs": [],
   "source": [
    "# given the type of feature selection type along with all the instances\n",
    "# iterates over different sets of features (based on the type of feature \n",
    "# selection given)\n",
    "# for each different set of feature, finds leave-one-out validation accuracy\n",
    "# using nearest neighbor classifier (k = 1)\n",
    "# prints the best accuracy with the best feature set\n",
    "# returns the best accuracy to best feature set per level to plot graph \n",
    "def start_experiment(instances, instance_count, feature_count, \\\n",
    "                     search_type = FORWARD_SELECTION):\n",
    "    \n",
    "    print()\n",
    "    print()\n",
    "    print(search_type.upper())\n",
    "    accuracy_map = {}\n",
    "    \n",
    "    all_feature_set = list(range(1, feature_count + 1))\n",
    "    accuracy = leave_one_out_cross_validation(\\\n",
    "                    instances, instance_count, all_feature_set)\n",
    "    print('Running nearest neighbor with all', feature_count, \\\n",
    "          'features, using leave-one-out evaluation',\n",
    "         'with accuracy', '{:0.1f}%'.format(accuracy * 100))\n",
    "    accuracy_map[len(all_feature_set)] = accuracy\n",
    "    \n",
    "    # starts with an empty feature set for forward selection\n",
    "    # starts with all features for backward elimination\n",
    "    if search_type == FORWARD_SELECTION:\n",
    "        current_feature_set = []\n",
    "    elif search_type == BACKWARD_ELIMINATION:\n",
    "        current_feature_set = all_feature_set\n",
    "    \n",
    "    print()\n",
    "    print('Beginning Search ')\n",
    "    best_accuracy_feature_set = all_feature_set\n",
    "    best_accuracy = accuracy\n",
    "    \n",
    "    # iterating over each of the level\n",
    "    # on each level, either the count of features\n",
    "    # equal to  (level count) (forward selection)\n",
    "    # or (total feature count - level count) (backward elimination)\n",
    "    for level in range(1, feature_count):\n",
    "        \n",
    "        print('On the ', str(level), 'th level of the search tree')\n",
    "        level_wise_best_accuracy_feature_set = None\n",
    "        level_wise_best_accuracy_feature = None\n",
    "        level_wise_best_accuracy = 0\n",
    "        \n",
    "        # iterating over each of the features which can be added\n",
    "        # or removed for feature selection/backward elimination\n",
    "        # respectively\n",
    "        for feature in range(1, feature_count + 1):\n",
    "            \n",
    "            if (feature not in current_feature_set and \\\n",
    "                search_type == FORWARD_SELECTION) or \\\n",
    "                (feature in current_feature_set and \\\n",
    "                 search_type == BACKWARD_ELIMINATION):\n",
    "                \n",
    "                if search_type == FORWARD_SELECTION:\n",
    "                    feature_set = current_feature_set + [feature]\n",
    "                elif search_type == BACKWARD_ELIMINATION:\n",
    "                    feature_set = list(set(current_feature_set) - set([feature]))\n",
    "                \n",
    "                # finding leave one out cross validation accuracy\n",
    "                accuracy = leave_one_out_cross_validation(\\\n",
    "                                instances, instance_count, \\\n",
    "                                feature_set)\n",
    "                \n",
    "                # sorting for displaying results in good manner\n",
    "                feature_set.sort()\n",
    "                feature_set_string = '{' + ','.join(str(f) \\\n",
    "                                                    for f in feature_set) + '}'\n",
    "                print('\\t Using features',  feature_set_string, 'accuracy is', \\\n",
    "                      '{:0.1f}%'.format(accuracy * 100) )\n",
    "                \n",
    "                # checks if current feature set provides the better accuracy\n",
    "                # among the feature sets in the current level\n",
    "                if accuracy > level_wise_best_accuracy:\n",
    "                    level_wise_best_accuracy = accuracy\n",
    "                    level_wise_best_accuracy_feature = feature\n",
    "                    level_wise_best_accuracy_feature_set = feature_set\n",
    "                    \n",
    "        if search_type == FORWARD_SELECTION:\n",
    "            current_feature_set.append(level_wise_best_accuracy_feature)\n",
    "            add_remove_log = 'adding ' + 'feature ' + \\\n",
    "                str(level_wise_best_accuracy_feature)\n",
    "        elif search_type == BACKWARD_ELIMINATION:\n",
    "            current_feature_set = list(set(current_feature_set) - \\\n",
    "                                        set([level_wise_best_accuracy_feature]))\n",
    "            add_remove_log = 'removing ' + 'feature ' + \\\n",
    "                              str(level_wise_best_accuracy_feature)\n",
    "            \n",
    "        \n",
    "        level_wise_best_feature_set_string = '{' + ','.join(str(f) \\\n",
    "                            for f in level_wise_best_accuracy_feature_set) + '}'\n",
    "        print('Feature set ', level_wise_best_feature_set_string, \\\n",
    "              ' was best. accuracy is', '{:0.1f}%'.format(\\\n",
    "                                level_wise_best_accuracy*100), add_remove_log )\n",
    "        \n",
    "        accuracy_map[len(level_wise_best_accuracy_feature_set)] = \\\n",
    "                                level_wise_best_accuracy\n",
    "        print()\n",
    "        \n",
    "        # checks if current level accuracy is best among the so far\n",
    "        # feature sets considered\n",
    "        if level_wise_best_accuracy > best_accuracy:\n",
    "            best_accuracy = level_wise_best_accuracy\n",
    "            best_accuracy_feature_set = level_wise_best_accuracy_feature_set\n",
    "    \n",
    "    # displays the best accuracy calculated with the best feature set\n",
    "    best_accuracy_feature_set_string = '{' + ','.join(str(f) \\\n",
    "                                for f in best_accuracy_feature_set) + '}'\n",
    "    print('Finished search !!', 'The best feature subset is', \\\n",
    "                                best_accuracy_feature_set_string, \\\n",
    "             'which has an accuracy of', '{:0.1f}%'.format(best_accuracy*100) )\n",
    "    \n",
    "    return accuracy_map\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3b4dd1f1",
   "metadata": {
    "id": "3b4dd1f1",
    "outputId": "07e9e60d-276d-4023-ab22-bfee0f81be21"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Press 11 to run Forward Selection with small dataset\n",
      "Press 12 to run Forward Selection with large dataset\n",
      "Press 21 to run Backward Elimination with small dataset\n",
      "Press 22 to run Backward Elimination with large dataset\n",
      "Press any other key to exit\n",
      "11\n",
      "Forward Selection selected with small dataset\n",
      "\n",
      "\n",
      "FORWARD_SELECTION\n",
      "Running nearest neighbor with all 10 features, using leave-one-out evaluation with accuracy 72.3%\n",
      "\n",
      "Beginning Search \n",
      "On the  1 th level of the search tree\n",
      "\t Using features {1} accuracy is 67.4%\n",
      "\t Using features {2} accuracy is 65.7%\n",
      "\t Using features {3} accuracy is 69.7%\n",
      "\t Using features {4} accuracy is 66.3%\n",
      "\t Using features {5} accuracy is 71.0%\n",
      "\t Using features {6} accuracy is 73.3%\n",
      "\t Using features {7} accuracy is 76.3%\n",
      "\t Using features {8} accuracy is 90.3%\n",
      "\t Using features {9} accuracy is 69.7%\n",
      "\t Using features {10} accuracy is 68.0%\n",
      "Feature set  {8}  was best. accuracy is 90.3% adding feature 8\n",
      "\n",
      "On the  2 th level of the search tree\n",
      "\t Using features {1,8} accuracy is 88.0%\n",
      "\t Using features {2,8} accuracy is 82.7%\n",
      "\t Using features {3,8} accuracy is 83.0%\n",
      "\t Using features {4,8} accuracy is 81.3%\n",
      "\t Using features {5,8} accuracy is 81.7%\n",
      "\t Using features {6,8} accuracy is 84.7%\n",
      "\t Using features {7,8} accuracy is 96.3%\n",
      "\t Using features {8,9} accuracy is 82.0%\n",
      "\t Using features {8,10} accuracy is 85.0%\n",
      "Feature set  {7,8}  was best. accuracy is 96.3% adding feature 7\n",
      "\n",
      "On the  3 th level of the search tree\n",
      "\t Using features {1,7,8} accuracy is 89.0%\n",
      "\t Using features {2,7,8} accuracy is 89.3%\n",
      "\t Using features {3,7,8} accuracy is 90.0%\n",
      "\t Using features {4,7,8} accuracy is 87.3%\n",
      "\t Using features {5,7,8} accuracy is 91.7%\n",
      "\t Using features {6,7,8} accuracy is 92.0%\n",
      "\t Using features {7,8,9} accuracy is 93.0%\n",
      "\t Using features {7,8,10} accuracy is 94.3%\n",
      "Feature set  {7,8,10}  was best. accuracy is 94.3% adding feature 10\n",
      "\n",
      "On the  4 th level of the search tree\n",
      "\t Using features {1,7,8,10} accuracy is 85.7%\n",
      "\t Using features {2,7,8,10} accuracy is 85.3%\n",
      "\t Using features {3,7,8,10} accuracy is 87.7%\n",
      "\t Using features {4,7,8,10} accuracy is 89.6%\n",
      "\t Using features {5,7,8,10} accuracy is 85.7%\n",
      "\t Using features {6,7,8,10} accuracy is 90.3%\n",
      "\t Using features {7,8,9,10} accuracy is 87.0%\n",
      "Feature set  {6,7,8,10}  was best. accuracy is 90.3% adding feature 6\n",
      "\n",
      "On the  5 th level of the search tree\n",
      "\t Using features {1,6,7,8,10} accuracy is 85.6%\n",
      "\t Using features {2,6,7,8,10} accuracy is 81.3%\n",
      "\t Using features {3,6,7,8,10} accuracy is 83.0%\n",
      "\t Using features {4,6,7,8,10} accuracy is 87.0%\n",
      "\t Using features {5,6,7,8,10} accuracy is 84.3%\n",
      "\t Using features {6,7,8,9,10} accuracy is 83.6%\n",
      "Feature set  {4,6,7,8,10}  was best. accuracy is 87.0% adding feature 4\n",
      "\n",
      "On the  6 th level of the search tree\n",
      "\t Using features {1,4,6,7,8,10} accuracy is 79.7%\n",
      "\t Using features {2,4,6,7,8,10} accuracy is 81.6%\n",
      "\t Using features {3,4,6,7,8,10} accuracy is 85.0%\n",
      "\t Using features {4,5,6,7,8,10} accuracy is 79.3%\n",
      "\t Using features {4,6,7,8,9,10} accuracy is 79.0%\n",
      "Feature set  {3,4,6,7,8,10}  was best. accuracy is 85.0% adding feature 3\n",
      "\n",
      "On the  7 th level of the search tree\n",
      "\t Using features {1,3,4,6,7,8,10} accuracy is 78.0%\n",
      "\t Using features {2,3,4,6,7,8,10} accuracy is 78.3%\n",
      "\t Using features {3,4,5,6,7,8,10} accuracy is 80.7%\n",
      "\t Using features {3,4,6,7,8,9,10} accuracy is 74.0%\n",
      "Feature set  {3,4,5,6,7,8,10}  was best. accuracy is 80.7% adding feature 5\n",
      "\n",
      "On the  8 th level of the search tree\n",
      "\t Using features {1,3,4,5,6,7,8,10} accuracy is 79.6%\n",
      "\t Using features {2,3,4,5,6,7,8,10} accuracy is 77.7%\n",
      "\t Using features {3,4,5,6,7,8,9,10} accuracy is 78.0%\n",
      "Feature set  {1,3,4,5,6,7,8,10}  was best. accuracy is 79.6% adding feature 1\n",
      "\n",
      "On the  9 th level of the search tree\n",
      "\t Using features {1,2,3,4,5,6,7,8,10} accuracy is 76.3%\n",
      "\t Using features {1,3,4,5,6,7,8,9,10} accuracy is 77.0%\n",
      "Feature set  {1,3,4,5,6,7,8,9,10}  was best. accuracy is 77.0% adding feature 9\n",
      "\n",
      "Finished search !! The best feature subset is {7,8} which has an accuracy of 96.3%\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Execution time  5535.1 seconds\n",
      "\n",
      "\n",
      "Press 11 to run Forward Selection with small dataset\n",
      "Press 12 to run Forward Selection with large dataset\n",
      "Press 21 to run Backward Elimination with small dataset\n",
      "Press 22 to run Backward Elimination with large dataset\n",
      "Press any other key to exit\n",
      "21\n",
      "Backward Elimination selected with small dataset\n",
      "\n",
      "\n",
      "BACKWARD_ELIMINATION\n",
      "Running nearest neighbor with all 10 features, using leave-one-out evaluation with accuracy 72.3%\n",
      "\n",
      "Beginning Search \n",
      "On the  1 th level of the search tree\n",
      "\t Using features {2,3,4,5,6,7,8,9,10} accuracy is 75.3%\n",
      "\t Using features {1,3,4,5,6,7,8,9,10} accuracy is 77.0%\n",
      "\t Using features {1,2,4,5,6,7,8,9,10} accuracy is 74.0%\n",
      "\t Using features {1,2,3,5,6,7,8,9,10} accuracy is 73.3%\n",
      "\t Using features {1,2,3,4,6,7,8,9,10} accuracy is 69.0%\n",
      "\t Using features {1,2,3,4,5,7,8,9,10} accuracy is 72.3%\n",
      "\t Using features {1,2,3,4,5,6,8,9,10} accuracy is 71.0%\n",
      "\t Using features {1,2,3,4,5,6,7,9,10} accuracy is 68.7%\n",
      "\t Using features {1,2,3,4,5,6,7,8,10} accuracy is 76.3%\n",
      "\t Using features {1,2,3,4,5,6,7,8,9} accuracy is 72.7%\n",
      "Feature set  {1,3,4,5,6,7,8,9,10}  was best. accuracy is 77.0% removing feature 2\n",
      "\n",
      "On the  2 th level of the search tree\n",
      "\t Using features {3,4,5,6,7,8,9,10} accuracy is 78.0%\n",
      "\t Using features {1,4,5,6,7,8,9,10} accuracy is 74.3%\n",
      "\t Using features {1,3,5,6,7,8,9,10} accuracy is 74.3%\n",
      "\t Using features {1,3,4,6,7,8,9,10} accuracy is 73.0%\n",
      "\t Using features {1,3,4,5,7,8,9,10} accuracy is 77.6%\n",
      "\t Using features {1,3,4,5,6,8,9,10} accuracy is 78.0%\n",
      "\t Using features {1,3,4,5,6,7,9,10} accuracy is 74.0%\n",
      "\t Using features {1,3,4,5,6,7,8,10} accuracy is 79.6%\n",
      "\t Using features {1,3,4,5,6,7,8,9} accuracy is 76.7%\n",
      "Feature set  {1,3,4,5,6,7,8,10}  was best. accuracy is 79.6% removing feature 9\n",
      "\n",
      "On the  3 th level of the search tree\n",
      "\t Using features {3,4,5,6,7,8,10} accuracy is 80.7%\n",
      "\t Using features {1,4,5,6,7,8,10} accuracy is 79.3%\n",
      "\t Using features {1,3,5,6,7,8,10} accuracy is 78.3%\n",
      "\t Using features {1,3,4,6,7,8,10} accuracy is 78.0%\n",
      "\t Using features {1,3,4,5,7,8,10} accuracy is 79.7%\n",
      "\t Using features {1,3,4,5,6,8,10} accuracy is 79.3%\n",
      "\t Using features {1,3,4,5,6,7,10} accuracy is 75.0%\n",
      "\t Using features {1,3,4,5,6,7,8} accuracy is 76.0%\n",
      "Feature set  {3,4,5,6,7,8,10}  was best. accuracy is 80.7% removing feature 1\n",
      "\n",
      "On the  4 th level of the search tree\n",
      "\t Using features {4,5,6,7,8,10} accuracy is 79.3%\n",
      "\t Using features {3,5,6,7,8,10} accuracy is 79.3%\n",
      "\t Using features {3,4,6,7,8,10} accuracy is 85.0%\n",
      "\t Using features {3,4,5,7,8,10} accuracy is 80.6%\n",
      "\t Using features {3,4,5,6,8,10} accuracy is 80.0%\n",
      "\t Using features {3,4,5,6,7,10} accuracy is 75.3%\n",
      "\t Using features {3,4,5,6,7,8} accuracy is 82.6%\n",
      "Feature set  {3,4,6,7,8,10}  was best. accuracy is 85.0% removing feature 5\n",
      "\n",
      "On the  5 th level of the search tree\n",
      "\t Using features {4,6,7,8,10} accuracy is 87.0%\n",
      "\t Using features {3,6,7,8,10} accuracy is 83.0%\n",
      "\t Using features {3,4,7,8,10} accuracy is 81.7%\n",
      "\t Using features {3,4,6,8,10} accuracy is 83.6%\n",
      "\t Using features {3,4,6,7,10} accuracy is 72.7%\n",
      "\t Using features {3,4,6,7,8} accuracy is 86.0%\n",
      "Feature set  {4,6,7,8,10}  was best. accuracy is 87.0% removing feature 3\n",
      "\n",
      "On the  6 th level of the search tree\n",
      "\t Using features {6,7,8,10} accuracy is 90.3%\n",
      "\t Using features {4,7,8,10} accuracy is 89.6%\n",
      "\t Using features {4,6,8,10} accuracy is 81.0%\n",
      "\t Using features {4,6,7,10} accuracy is 71.0%\n",
      "\t Using features {4,6,7,8} accuracy is 85.6%\n",
      "Feature set  {6,7,8,10}  was best. accuracy is 90.3% removing feature 4\n",
      "\n",
      "On the  7 th level of the search tree\n",
      "\t Using features {7,8,10} accuracy is 94.3%\n",
      "\t Using features {6,8,10} accuracy is 84.7%\n",
      "\t Using features {6,7,10} accuracy is 74.3%\n",
      "\t Using features {6,7,8} accuracy is 92.0%\n",
      "Feature set  {7,8,10}  was best. accuracy is 94.3% removing feature 6\n",
      "\n",
      "On the  8 th level of the search tree\n",
      "\t Using features {8,10} accuracy is 85.0%\n",
      "\t Using features {7,10} accuracy is 72.3%\n",
      "\t Using features {7,8} accuracy is 96.3%\n",
      "Feature set  {7,8}  was best. accuracy is 96.3% removing feature 10\n",
      "\n",
      "On the  9 th level of the search tree\n",
      "\t Using features {8} accuracy is 90.3%\n",
      "\t Using features {7} accuracy is 76.3%\n",
      "Feature set  {8}  was best. accuracy is 90.3% removing feature 7\n",
      "\n",
      "Finished search !! The best feature subset is {7,8} which has an accuracy of 96.3%\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAzFUlEQVR4nO3dd3hUZdrH8e+dRiB0iPReFEFqKIpiV3RVdK2sDSysa3ddV9d9t+nuvrq6utYVV0HEgg1fu2KlCUJQEEERBBSkg/SacL9/nBMcswMZIJMzSX6f68qVzClz7jlJ5jfnOec8j7k7IiIixaVFXYCIiKQmBYSIiMSlgBARkbgUECIiEpcCQkRE4lJAiIhIXAoIERGJSwEhIpIAMzvKzBbHPF5oZsdFWVOyKSBSSPgHt8XMNprZD2b2hpk1i7Pcn83MzaxXnHm9zOxNM1trZmvMbIqZDQ7nFf8DzzKz0WY20cz+ZGZvFnuuubuZdl5JtZjZIDMrDF/LejObYWanxMxvGa63Mfxabmavm9nx+7Cvir4ejNn2hN2s95GZXRazP9zMRhdbpks4/aOYaW5mbYu95rNj5meE01oWe66f7B8zOz+m3i1mtjP2NcS8tuNinqOpmT1tZqvNbFP4Oz2l2HbczGaaWVrMtL+a2RO72Q9HFdv2YjN73sx67mG3F3+OP5vZU4kuv6/Kajvy3xQQqedUd68ONAKWAw/EzjQzAy4E1gAXF5t3KPABMBZoC9QDfgWcVHwjZlYFGA3UBk4A3gP6mll6OL8hkAl0LzatLTCupFpCk8LXUht4GBhlZrWLLVM7XKYL8C7wspkN2v3u+YlT3b16zNfVCa4XayVwmJnVi5l2MfB1CeutAW4r2jfxxNs/7v50Ub0Ev5clsa8hznPUBSYA24GOQH3gXuAZMzur2OKNgfNI3JJwmzWAPsBXwHgzO3YvnkMqMAVEinL3rcCLwMHFZh1B8EZwHXCemWXFzLsLGOHud7r7Kg9Mc/dzYp/AzKoBrxEEwM/cfRMwNXzcNVysH/AhMKfYtG/cfUkCtcS+lp3ASCAHaLebZZa5+33An4E7Yz8JJ9l24P8I31jDN/xzgKdLWO/tcN0L9rBMQvunBDcAG4FLw320xd2fBf4G/DMMoSL/AP5iZhl7s4Hw72Sxu/8ReAy4s2iemd1nZovCo8BpZnZEOL0/cCtwbngEMiOcPtjMvjSzDWY238x+GfNc9cOjxKKj2/FFv2cza2xmL5nZSjNbYGbX7mk7xZnZzWb2fbjdOUUhFx59vGBmT4XzZppZezP7nZmtCF/bCTHPs9v6KyMFRIoK38TPBSYXm3UxwZv7c+HjU2KWP5QgVPakCvAWsBU4zd23ALj7duATghAg/D6e4NNr7LRxJdUS57WkA4OBHcC3JdQ3GjgAOLCE5UrTk8BF4c8nArOAJbtfHAAH/gD8ycwyd7NMQvunBMcDL4UhG+t5oDnQPmbaaGA9MGgfthP7HN3NLCd8PJXgA0Jd4BngBTPLdve3gb8Dz4VHP13C5VcQvM6aBL/ze82sezjvRmAxkAs0IHjj9zAkXgNmAE2AY4HrzezEPWxnFzM7ELga6OnuNQh+hwtjFjmV4ANKHeAz4B2C974mwG3A0Jhl91R/paOASD3/Z2ZrCf7Rjyc4KgB2hcDZwDPuvoMgDIqaduoQ/D6XlvD8NQiCZIS7bys2byw/hsERBAExvti0sQnUUqRP+Fq2AncDF7j7ihLqK3pjrlvCchDuq5ivyxNY57+4+8dA3fCN5iKCwEhkvVcJmqguKz4vwf2TiPrE/50ujZm/qySC0Ppj2IS4L5YARtAsiLs/5e6r3b3A3f9J8AFjt+Ht7m+4+zfhUclYYAzB3w0EHxAaAS3cfYe7j/egt9CeQK673+bu2919PvAfEm8uKwzrOtjMMt19obt/EzN/vLu/4+4FwAsEAXVH+HsZBbQsavosof5KRwGRek5399oEf/BXA2PDtn+AM4ACoOjE8dPASWaWC/wA7CT4B9yTVQT/eCPM7MRi88YBh5tZHYJ/2LnAxwRt9HWATvx4BLGnWopMDl9LHeBVEvtHaxJ+X5PAsqe7e+2Yr/8ksM7ujCTY30cDL+/Fev8D/B7ILjY9kf2TiFXE/502ipm/i7u/CXwHDNnL7RRpQhA0awHM7MawyWVdGPa1+Gko/YSZnWRmk8MmpLXAyTHL3wXMA8aEzTe3hNNbAI1jw57g6KJBIgW7+zzgeoLmyRVmNsrMGscssjzm5y3AKncvjHkMUD2B+isdBUSKcvdCdx9N8Ono8HDyxQR/yN+Z2TKCT0OZwEB33wxMAs5M4LlHA5cDL5rZ0TGzJhG8AQwBJobLrif4VDmE4KTmgpJqibO9jcCVwIVm1q2E8s4gOMyfU9LrKGUjCWp8M9yXCXH3dwne9K4sNivh/VOC94Az45yTOQdYRPyT6UWhVW0vtwXB/v/U3TeF5xtuDrdVJwz7dQRHGBAEyS7hUctLBEeLDcLl3yxa3t03uPuN7t6aoNnn1+G5gkXAgmJhX8PdT463nXjc/Rl3P5wgbJyY8yiJKqn+ykgBkaIsMIDg0/eXZlbUNnsKQZtwV4Irf+7kx6aL3wKDzOwmC6/KseCSzVHFnz880Xk18IqZ9Q2nbQHygV8TNC0VmRBOK7p6KZFaim9vNcEJ0D/u5vU2MLOrgT8Bv4vT5r63zMyyY7/2tHAYfEcSvLHurd8T7PuiDe/1/tmDewnawx83s4bhaxkYbvMmjzOgi7t/BMxMdFvh31oTM/sTQXPZreGsGgRHQSuBDDP7Y1hLkeUEzTNF7yNZBEe+K4ECMzuJ4Aq5ou2cYmZtzcwImlALw68pwPrwRHNVM0s3s0724yW3xbdTvP4DzeyY8A1+K8FRQWG8ZUuwx/orIwVE6nnNguvh1xNcqXKxu88iuFxyuruPCa9mWebuy4D7gc5m1ilsSz8m/JpvZmuAR/mxmeMn3H0EwYnDN+zH+xjGEpwkjr2PYHw4rah5qcRadvPa/gWcbGadY6atNbNNBG9oJwNnu/uwhPZUuK9ivmKbhg4jeKPY9WUlXN3j7hNirtBKmLtPJHiTK7Kv+yfec68mOILMBmYDqwnC+kJ3f24Pq/4PJZ/HaRz+rW0kOBl9CHCUu48J579DcEHD1wQXF2wl+LRf5IXw+2oz+9TdNwDXEpxA/wH4BUHTYpF2BEdEGwmOVh9294/C5p5TCYJ0AUGz2WMER7P/tZ04r6MKcEe43jKCv9Vb4yy3RwnUX+lYnA8gIiIiOoIQEZH49uqGGpGyYmbNCZpU4jnY3b8ry3pEKiM1MYmISFwV6giifv363rJly6jLEBEpN6ZNm7bK3ePen1OhAqJly5bk5+dHXYaISLlhZrvt/kYnqUVEJC4FhIiIxKWAEBGRuBQQIiISlwJCRETiUkCIiEhcCggREYlLAZEiCgp38vQn3/L18g1RlyIiAlSwG+XKs6Hj5nPXO3Mwg5M6NeTqo9txcOOaJa8oIpIkCogUMHvJev713tec2LEB7Q6owYiPF/LmzGUc16EB1x7bls5Na0ddoohUQgqIiG0rKOTXz0+ndrUs7vh5Z+rkZHH5Ea0Z/vEChk1YwGkPLueoA3O55ph29GhRJ+pyRaQS0TmIiP3rvbl8tWwDd555CHVysgCoVS2T649rz8RbjuGmEw/k88XrOPPfH3P+Y5OZPH91xBWLSGWhgIjQtG/XMHTsN5yb14xjDmrwX/NrZGdy1dFtmXDz0fz+5A7MWbaR8x6dzDlDJzFh7irUVbuIJFOFGg8iLy/Py0tvrpu3F3DSfeMp3Om8dd0R1MjOLHGdrTsKeXbKdwwdO59l67fSrXltrj22HUe1zyUYB15EZO+Y2TR3z4s3T0cQEfnfN7/iuzWbufvsLgmFA0B2ZjqD+7Zi7G+P4q+nd2LF+m0MHj6VAQ9NZMysZTqiEJFSpYCIwPi5Kxk5+Vsu6duKPq3r7fX6VTLSuaBPCz78zVHceeYhrN28gyEjp3HSfeN54/Ol7NypoBCR/ZfUgDCz/mY2x8zmmdktcebXMbOXzexzM5tiZp1i5i00s5lmNt3Myke7UQLWbdnBTS98TtsDqnPTiQfu13NlZaRxbs/mfHDjkdxzThe2F+7kqmc+5cR/jeOV6d9TqKAQkf2QtIAws3TgIeAk4GBgoJkdXGyxW4Hp7t4ZuAi4r9j8o9296+7ax8qjv7w6i5Ubt3HPOV3IzkwvlefMSE/j592b8u4NR/LAwG6YwXWjpnPcPWN5cdpidhTuLJXtiEjlkswjiF7APHef7+7bgVHAgGLLHAy8D+DuXwEtzey/L+epIN7+YhmjP/ueq45Ozs1v6WnGqV0a8/Z1/Xjkgu5UzUznNy/M4Jh/fsSzU75je4GCQkQSl8yAaAIsinm8OJwWawbwcwAz6wW0AJqG8xwYY2bTzGzI7jZiZkPMLN/M8leuXFlqxZe2VRu38fuXZ9KpSU2uOaZtUreVlmb079SIN649nMcuyqNutSx+N3omR931ISMnLWTrjsKkbl9EKoZkBkS86y6LN4rfAdQxs+nANcBnQEE4r6+7dydoorrKzPrF24i7P+ruee6el5ubWzqVlzJ353ejZ7JhWwH3nNOVzPSyuTbAzDju4Ab831V9GXFJLxrXrsofXpnFkXd9yOMTFrBlu4JCRHYvmV1tLAaaxTxuCiyJXcDd1wODASy4kH9B+IW7Lwm/rzCzlwmarMYlsd6keenT73l39nJ+f3IH2jeoUebbNzOObJ9Lv3b1mTR/Nfe/P5fbX5/Nvz+ax+VHtOaCPi3IqaJeV0Tkp5L5UXYq0M7MWplZFnAe8GrsAmZWO5wHcBkwzt3Xm1mOmdUIl8kBTgC+SGKtSfP92i385dVZ9GpZl0sObxVpLWbGYW3qM2rIobxwxaF0aFST/33rKw6/8wMe/GAu67fuiLQ+EUktSfvY6O4FZnY18A6QDgxz91lmdkU4/xGgA/CkmRUCs4FLw9UbAC+HdwdnAM+4+9vJqjVZdu50fvviDArdufvsLqSnpc7dzj1b1mXkpb357LsfeOCDedw95mseHTefwX1bcUnfVtSqltjNeyJScamrjSQa8fFC/vTqLP5+xiH8onfzqMvZoy++X8cDH8zlnVnLqZGdwdALe3BYm/pRlyUiSaauNiIwf+VG/vetLznqwFwG9mpW8goR69SkFkMvzOPt64+gUa1sLnliKuPnpu5VYSKSfAqIJCgo3MmNL8ygSkY6d57ZuVx1pHdQw5o8e3kfWtWvzqUj8vnwqxVRlyQiEVFAJMHQcfP57Lu13H56JxrUzI66nL1Wr3oVnr28Nwc2qMGQkfmMmbUs6pJEJAIKiFJWNHzozzo34rQujaMuZ5/VrpbFU5f1pmPjWlz59Ke8OXNp1CWJSBlTQJSi2OFD/zqgU8krpLhaVTMZeWkvujarzTXPfsYr07+PuiQRKUMKiFIUb/jQ8q5GdiYjLulFz5Z1uOG56bw4bXHUJYlIGVFAlJKShg8tz3KqZDB8UC8Oa1Ofm16cwagp30VdkoiUAQVEKdi8vYAbn59Bo1pV+Z9TOkRdTlJUzUrnsYvzOLJ9LreMnsnISQujLklEkkwBUQrueOsrFq7eu+FDy6PszHSGXtiD4zo04A+vzOLxCQuiLklEkkgBsZ8mzF3Fk5OC4UMPbbP3w4eWN1Uy0nn4/O6c1Kkht78+m0fGfhN1SSKSJAqI/bBuyw5uenEGbXJz+G3//Rs+tDzJykjjgYHdOK1LY+546yvuf39u1CWJSBKoj+f98JdXZ7FiwzZevvKwUhs+tLzISE/j3nO7kpFu3PPu1+wo3Mmvj29fru4aF5E9U0Dso6LhQ689tl1Shg8tD9LTjLvP6kJWehoPfDCP7YU7uaX/QQoJkQpCAbEPynL40FSXlmb8/YxDyEg3ho6dz44C5w+ndFBIiFQACoi95O7cGg4f+mwZDh+aytLSjNsHdCIzPY1hExewo3AnfzmtI2kpNP6FiOw9BcReGv3p94yZvZxbTz4okuFDU5WZ8cdTDiYrIy04kijcyd/POEQhIVKOKSD2wpK1W/hzOHzopYe3jrqclGNm3NL/oF3nJHYUOv84q3NKjaQnIolTQCQoGD7085QcPjSVmBk3nnAgmelpu65uuuecLmSoKU6k3FFAJOipT75lwrxV/P2MQ2her1rU5aS8a49tR2Z6Gne+/RUFO3dy33nddL5GpJxRQCRg/sqN/P3N8jN8aKr41VFtyEw3/vrGl+wo/JQHf9GNKhmV634RkfJMH+lKUJ6HD00Flx3RmtsGdOTd2cu5YuQ0tu4ojLokEUmQAqIERcOH3jagY7kcPjQVXHRoS/7354fw0dcrufzJfLZsV0iIlAcKiD3YNXzoIeV7+NBUMLBXc+46qwsT5q1i8BNT2LStIOqSRKQECojdKBo+tFbVLG4/vZOalkrBWT2a8q9zuzJ14Q9cPGwKG7buiLokEdkDBcRu3BczfGjdCjJ8aCoY0LUJ95/XjemL1nLh41NYt0UhIZKqFBBxTPv2Bx4Jhw89tkPFGj40FfyscyMePr87s5as44LHPmHt5u1RlyQicSggitm8vYDfvFCxhw9NBSd0bMijF+YxZ/kGBv7nE1Zv3BZ1SSJSjAKimDve+ooFqzZV+OFDU8HRBx3AYxflMX/lRgb+ZzIrNygkRFKJAiJGZRs+NBX0a5/L8ME9WbRmC+c9Oonl67dGXZKIhBQQoco6fGgqOKxNfUZc0otl67Zy7tBJLFm7JeqSRAQFxC5/eS0YPvSec7pWuuFDU0GvVnUZeVlvVm/azrmPTmLRms1RlyRS6SkggHdmLWP0p99z1VFt6NKsdtTlVFrdm9fh6ct6s35LAecOncS3qzdFXZJIpZbUgDCz/mY2x8zmmdktcebXMbOXzexzM5tiZp0SXbe0rNu8g1tHB8OHXn1Mu2RtRhLUuWltnrm8N1sLdnL2I5OYvmht1CWJVFpJCwgzSwceAk4CDgYGmtnBxRa7FZju7p2Bi4D79mLdUlGzaga/7X8g95zTlawMHVClgo6NazFqSB+yMtI4Z+gkXpq2OOqSRCqlZL4j9gLmuft8d98OjAIGFFvmYOB9AHf/CmhpZg0SXLdUmBnn9myu4UNTTPsGNXj16sPp0bwON74wg9tfn01B4c6oyxKpVJIZEE2ARTGPF4fTYs0Afg5gZr2AFkDTBNclXG+ImeWbWf7KlStLqXRJBXVzsnjy0l4MOqwlj09YwKDhU3XXtUgZSmZAxOvdzos9vgOoY2bTgWuAz4CCBNcNJro/6u557p6Xm5u7H+VKKspMT+PPp3XkH2d2ZsqCNZz24ES+Xr4h6rJEKoVkBsRiIHb4tabAktgF3H29uw92964E5yBygQWJrCuVyzk9m/HskD5s2VHIGQ9N5J1Zy6IuSaTCS2ZATAXamVkrM8sCzgNejV3AzGqH8wAuA8a5+/pE1pXKp0eLOrx29eG0PaA6vxw5jfvem8vOnXEPLEWkFCQtINy9ALgaeAf4Enje3WeZ2RVmdkW4WAdglpl9RXDF0nV7WjdZtUr50bBWNs/98lB+3r0J9773NVc+/akGHxJJEnOvOJ/A8vLyPD8/P+oypAy4O8MmLuRvb8ymfYMaPHphHs3rVYu6LJFyx8ymuXtevHm68F/KJTPj0sNbMeKSXixdt5XTHprAxHmroi5LpEJRQEi5dkS7XF65qi+51atw0bApDJ+4gIp0VCwSJQWElHst6+fw8lV9OeagA/jLa7P57Yufs62gMOqyRMo9BYRUCNWrZDD0gh5ce2w7Xpi2mPMencwKjS0hsl8UEFJhpKUZvz6+PY9c0J05yzZw6oMT1NmfyH5QQEiF079TI0Zfediuzv5eVGd/IvtEASEV0kENa/LqVYeT16IOv3lhBre9ps7+RPaWAkIqrDo5WTx5SS8G923JsIkLuHj4FH7YpM7+RBKlgJAKLSM9jT+d2pF/nNWZqQt+YMBDE5mzTJ39iSRCASGVwjl5zRj1y7Czv4cn8vYX6uxPpCQKCKk0ujcPOvtr16AGVzylzv5ESqKAkEqlYa1snhvShzO7N+Xe977mV09PY6M6+xOJSwEhlU52Zjp3n92ZP5xyMO/OXs6ZD3/Md6s3R12WSMpRQEilVNTZ35OX9GbZenX2JxKPAkIqtcPb1efVq/tyQI2gs79hE9TZn0gRBYRUei3q5TD6yr4ce9AB3Pb6bG568XO27lBnfyIKCBGCzv4euaAH1x3bjhfDzv6Wq7M/qeQUECKhtDTjhrCzv6+Xb+DUBybw6Xc/RF2WSGQUECLFFHX2VyUzjfOGTmbExwvZXqB+nKTyUUCIxFHU2V/v1nX506uzOPrujxg5+VsNRCSVigJCZDeKOvsbPrgnDWpW4Q//9wX9/vEhwyYsYMt2BYVUfFbSJX1mdgrwprun/DF2Xl6e5+fnR12GVEDuzqRvVnP/B3OZPH8N9atncdkRrbmgTwuqV8mIujyRfWZm09w9L+68BALiKeBQ4CVguLt/Wfollg4FhJSFqQvXcP/7cxk/dxW1q2VySd9WXHxYS2pVzYy6NJG9tl8BET5BTWAgMBhwYDjwrLunVL/JCggpS9MXreXBD+by3pcrqFElg0F9W3JJ31bUycmKujSRhO13QIRPUh+4ALge+BJoC9zv7g+UUp37TQEhUZi1ZB0PfjCPt75YRrWsdC7s04LLjmhNbo0qUZcmUqL9bWI6FbgEaAOMBEa4+wozqwZ86e4tSrvgfaWAkCh9vXwDD304j9dmLCErI42BvZrzy35taFgrO+rSRHZrfwPiSeAxdx8XZ96x7v5+6ZS5/xQQkgoWrNrEwx/O4+XPvifNjLPzmvKro9rQtE61qEsT+S/7GxCtgKXuvjV8XBVo4O4LS7vQ/aWAkFSyaM1m/j32G17MX8xOd87o1oSrjm5Ly/o5UZcmssv+BkQ+cJi7bw8fZwET3b1nqVe6nxQQkoqWrtvC0LHzeXbKd+wo3MlpXRpz1dFtadegRtSliewxIBK5US6jKBwAwp91mYZIghrVqsqfT+vI+JuP5rIjWjNm9nJO+Nc4rnx6GrOXrI+6PJHdSiQgVprZaUUPzGwAoJFVRPbSATWyufXkDky4+RiuOqot479excn3j+eyEfnMWLQ26vJE/ksiTUxtgKeBxoABi4CL3H1e8svbO2pikvJk3ZYdjPh4IY9PWMC6LTvo1z6Xa49pS17LulGXJpVIad0HUT1cPuGb48ysP3AfkE5wJdQdxebXAp4CmgMZwN3uPjyctxDYABQCBbt7AbEUEFIebdxWwMhJ3/LY+Pms3rSdPq3rcu0x7Ti0TT3MLOrypIIrjTupfwZ0BHZd0O3ut5WwTjrwNXA8sBiYCgx099kxy9wK1HL3m80sF5gDNHT37WFA5Ll7ws1ZCggpzzZvL+DZKYsYOvYbVmzYRo8Wdbj6mLYc1T5XQSFJs18nqc3sEeBc4BqCJqazgURujusFzHP3+eGJ7VHAgGLLOFDDgr/+6sAaoCCB5xapcKplZXDp4a0Y99ujuf30Tixbt5XBw6cy4KGJjJm1jJ07NVa2lK1ETlIf5u4XAT+4+18IOu5rlsB6TQjOVxRZHE6L9SDQAVgCzASui+k11oExZjbNzIbsbiNmNsTM8s0sf+XKlQmUJZLasjOD7jo+/M1R3HnmIazdvIMhI6cxZOQ0dhSmfKfKUoEkEhBFA/NuNrPGwA6gVQLrxTsmLv4R6ERgOsEJ8K7Ag2HHgAB93b07cBJwlZn1i7cRd3/U3fPcPS83NzeBskTKh6yMNM7t2ZwPbjySW08+iPe+XM71z02nUEcSUkYSCYjXzKw2cBfwKbAQeDaB9Rbz0yONpgRHCrEGA6M9MA9YABwE4O5Lwu8rgJcJmqxEKp2M9DSG9GvDrScfxBufL+Xmlz5Xc5OUiT2OdGJmacD77r4WeMnMXgey3X1dAs89FWgXdtXxPXAe8Itiy3wHHAuMN7MGwIHAfDPLAdLcfUP48wnAHk+Ki1R0Q/q1YdO2Qu57fy45Wen8+bSOOnktSbXHgHD3nWb2T4LzDrj7NmBbIk/s7gVmdjXwDsFlrsPcfZaZXRHOfwS4HXjCzGYSNEnd7O6rzKw18HL4x58BPOPub+/TKxSpQK4/rh2btxfwn/ELqJqVwc39D1RISNIkMlbiGDM7k7ApaG+e3N3fBN4sNu2RmJ+XEBwdFF9vPtBlb7YlUhmYGbee3IHN2wt5ZOw3VK+SztXHtIu6LKmgEgmIXwM5QIGZbSX4pO/uXnPPq4lIMpgZtw/oxJbthdw95muqhpfHipS2EgPC3dXlpEiKSUsz/nFWZzZvL+T212dTLSudgb2aR12WVDAlBsQeLi/9rwGERKTsZKSncf/AbgwZmc+tL8+kWlY6A7oWv9VIZN8l0sR0U8zP2QSXm04DjklKRSKSsKyMNB65oAeDhk/h18/PIDsznRM7Noy6LKkgSrwPwt1Pjfk6HugELE9+aSKSiOzMdB67uCeHNKnFNc98xtiv1aOAlI5EbpQrbjFBSIhIiqheJYMRg3vR5oDq/HJkPp/MXx11SVIBJNJZ3wNmdn/49SAwHpiR/NJEZG/UqpbJyEt70aR2VS7VIERSChI5gsgnOOcwDZhEcDPbBUmtSkT2Sf3qVXj6sj7UycnkomFT+HKphjSVfZdIQLwIPOXuI9z9aWCymVVLcl0iso8a1srmmcv6UDUznQsf/4T5KzdGXZKUU4kExPtA1ZjHVYH3klOOiJSGZnWr8fTlvQE4/7FPWLRmc8QVSXmUSEBku/uujyDhzzqCEElxbXKrM/LS3mzeXsj5j33C8vVbS15JJEYiAbHJzLoXPTCzHsCW5JUkIqWlQ6OajLikF6s3buP8xz5h9caE+toUARILiOuBF8xsvJmNB54Drk5qVSJSaro2q82wQT1Z/MNmLnx8Cuu27Ii6JCknErlRbirBID6/Aq4EOrj7tGQXJiKlp3fregy9MI+5KzYwaPgUNm3T0O9SskTug7gKyHH3L9x9JlDdzK5MfmkiUpqObJ/LAwO78/nidVw2Ip+tOwqjLklSXCJNTJeHI8oB4O4/AJcnrSIRSZr+nRryz7O7MHnBan711DS2F+yMuiRJYYkERJrFDFllZulAVvJKEpFkOr1bE/5+xiF8OGcl1z/3GQWFCgmJL5HeXN8BnjezRwAHrgDeSmpVIpJUA3s13zWWRHbm59x9VhfS0jR0qfxUIgFxMzCE4CS1AZ8BjZJZlIgk36WHt2LztgL++e7XVMtK5/YBnTS+tfxEIiPK7TSzyUBr4FygLvBSsgsTkeS7+pi2bArHt66WlcHvTjpIISG77DYgzKw9cB4wEFhNcP8D7n502ZQmIslmZtzc/0A2by/g0XHzycnK4Lrj2kVdlqSIPR1BfEXQtfep7j4PwMxuKJOqRKTMmBl/PrUjm7YVcu97QXPT5f1aR12WpIA9BcSZBEcQH5rZ28AognMQIlLBpKUZd555CFt3FPK3N7+kalY6F/RpEXVZErHdBoS7vwy8bGY5wOnADUADM/s38LK7jymbEkWkLGSkp3HvuV3ZsqOQP7zyBdWy0vl596ZRlyURSqSrjU3u/rS7nwI0BaYDtyS7MBEpe1kZaTx8fncObV2P37wwg7dmLo26JInQXo1J7e5r3H2oux+TrIJEJFrZmen856I8ujarzbWjPuPDOSuiLkkislcBISKVQ06VDIYP7kX7BjW4YuQ0Jn2zOuqSJAIKCBGJq1bVTEZe2pvmdatx6YipfPrdD1GXJGVMASEiu1U3J4unLutNbo0qDBo2hVlL1kVdkpQhBYSI7FGDmtk8fVlvqlfJ4MLHp/D81EUsWrMZd4+6NEkyq0i/5Ly8PM/Pz4+6DJEKaf7KjVw0bAqLfwhGHG5cK5s+revRu3Vd+rSuR/O61dRNRzlkZtPcPS/uPAWEiCRq505n7oqNfLJgNZPnr+aT+WtYvWk7AA1rZu8Ki96t6tKqfo4CoxyILCDMrD9wH5AOPObudxSbXwt4CmhOcNPe3e4+PJF141FAiJQtd2feio1MXrBmV2Cs2rgNgANqVKF363r0aV2X3q3q0SZXgZGKIgmIcGChr4HjgcXAVGCgu8+OWeZWoJa732xmucAcoCFQWNK68SggRKLl7sxftWlXWEyev5oVG4LAqF+9yq4jjD6t6tL2gOoKjBSwp4BIZDyIfdULmOfu88MiRgEDgNg3eQdqhCPWVQfWAAVA7wTWFZEUY2a0ya1Om9zqnN+7Be7OwtWbw8BYzeT5a3jj8+Du7Ho5WTFNUvVod0B1DVqUYpIZEE2ARTGPFxO88cd6EHgVWALUAM4Nx59IZF0RSXFmRqv6ObSqn8PAXs1xd75bs3nX0cXk+at5c+YyILiktlfLurtC48AGNRQYEUtmQMT7zRZvzzqRoG+nY4A2wLtmNj7BdYONmA0hGPGO5s2b72utIlIGzIwW9XJoUS+Hc3o2w91Z/MOWMCzW8MmC1bw9KwiM2tUyw8AIzmN0aFhTgVHGkhkQi4FmMY+bEhwpxBoM3OHBiZB5ZrYAOCjBdQFw90eBRyE4B1E6pYtIWTAzmtWtRrO61Tg7L/iXX/zDj0cYnyxYw5jZywGomZ1Br1ZBWBzaph4dG9eKsvRKIZkBMRVoZ2atgO8Jxpb4RbFlvgOOBcabWQPgQGA+sDaBdUWkAmpapxpNe1TjzB5BV+NL1m7hkwU/nvR+78sgMPp3bMhtAzpyQM3sKMut0JIWEO5eYGZXA+8QXKo6zN1nmdkV4fxHgNuBJ8xsJkGz0s3uvgog3rrJqlVEUlfj2lU5o1tTzugWBMaydVt56dPF3Pf+XD6+ZxV/OOVgzurRVFdEJYFulBORcumblRu55aXPmbrwB/q1z+XvZ3SiaZ1qUZdV7uzpMlf1xSQi5VKb3Oo8N+RQbhvQkfyFazjx3nE8OWkhO3dWnA+9UVNAiEi5lZZmXHRoS8bc0I/uLerwx1dmce6jk5i/cmPUpVUICggRKfea1qnGk5f04q6zOjNn2Qb63zeef3/0DQWFO6MurVxTQIhIhWBmnJ3XjPd+fSRHH5jLnW9/xRkPf8zsJeujLq3cUkCISIVyQM1sHrmgBw/9ojtL123htAcn8M8xc9hWUBh1aeWOAkJEKhwz42edG/HuDUdyWpfGPPDBPE65f4KGTd1LCggRqbDq5GRxz7ldGT6oJxu3FXDmvz/m9tdns2W7jiYSoYAQkQrv6IMOYMwN/Ti/d3Men7CAE/81jo+/WRV1WSlPASEilUKN7Ez+evohjBrShzSDX/znE343eibrt+6IurSUpYAQkUqlT+t6vHVdP4b0a81zU7/jhHvG8X7Yv5P8lAJCRCqdqlnp3HpyB16+si+1qmZy6Yh8rhv1GWvC8bUloIAQkUqrS7PavHbN4Vx3bDvenLmU4+4Zy6szllCR+qjbHwoIEanUsjLSuOH49rx2zeE0q1OVa5/9jMufnMby9VujLi1yCggREeCghjV56VeHcevJBzF+7kqOu2csz039rlIfTSggRERCGelpDOnXhrev70eHRjW5+aWZXPj4FBat2Rx1aZFQQIiIFNOqfg6jLu/DX0/vxPRFaznh3nEMn7iAwkrWlbgCQkQkjrQ044I+LRhzQz96t67LX16bzTlDJzFvxYaoSyszCggRkT1oXLsqwwf15N5zu/DNyo2cfN8EHvpwHjsqQVfiCggRkRKYGWd0a8q7NxzJ8Qc34K535jDgwYl88f26qEtLKgWEiEiCcmtU4aHzu/PIBd1ZuXEbZzw8kY/nVdw+nRQQIiJ7qX+nRoy5vh+t6ufwy5HT+GpZxRyUSAEhIrIP6uRk8cTgXlSrks6gYVNZum5L1CWVOgWEiMg+aly7Kk8M7sXGbQUMGjaVdVsqVs+wCggRkf3QoVFNhl7Yg29WbuSXI/Mr1NCmCggRkf3Ut219/nFWZybPX8NNL3zOzgpyQ11G1AWIiFQEP+/elKXrtnLXO3NoXLsqt5x0UNQl7TcFhIhIKbnyqDYsWbuFR8Z+Q+Pa2Vx0aMuoS9ovCggRkVJiZtw2oBPL12/jT6/OokHNbE7s2DDqsvaZzkGIiJSi9DTjgYHd6NK0Ntc++xnTvv0h6pL2mQJCRKSUVc1K5/GL82hUK5vLRkxl/sqNUZe0TxQQIiJJUK96FZ4Y3AszY9DwqazauC3qkvaaAkJEJEla1s/h8YvzWLFhK5c+MZXN2wuiLmmvKCBERJKoW/M6PDCwOzO/X8c1z3xGQTnqJjypAWFm/c1sjpnNM7Nb4sy/ycymh19fmFmhmdUN5y00s5nhvPxk1ikikkzHH9yA2wZ04v2vVvCHV2aVm3Guk3aZq5mlAw8BxwOLgalm9qq7zy5axt3vAu4Klz8VuMHd18Q8zdHuXnH70hWRSuOCPi1YsnYLD3/0DU3rVOWqo9tGXVKJknkfRC9gnrvPBzCzUcAAYPZulh8IPJvEekREInXTiQfuutu6Yc1szuzRNOqS9iiZTUxNgEUxjxeH0/6LmVUD+gMvxUx2YIyZTTOzIbvbiJkNMbN8M8tfuXJlKZQtIpIcZsadZ3amb9t63PzS54yfm9rvWckMCIszbXcNb6cCE4s1L/V19+7AScBVZtYv3oru/qi757l7Xm5u7v5VLCKSZFkZafz7gh60PaA6v3rqU2YtSd1hS5MZEIuBZjGPmwJLdrPseRRrXnL3JeH3FcDLBE1WIiLlXs3sTIYP7kmN7AwGD5/K92tTc7ChZAbEVKCdmbUysyyCEHi1+EJmVgs4EnglZlqOmdUo+hk4AfgiibWKiJSpRrWCwYa27Chk0LAprNuceoMNJS0g3L0AuBp4B/gSeN7dZ5nZFWZ2RcyiZwBj3H1TzLQGwAQzmwFMAd5w97eTVauISBQObFiDoRf2YOHqTVyegoMNWXm5HjcReXl5np+vWyZEpHx5Zfr3XDdqOqd0bsT953UjLS3eKdzkMLNp7p4Xb566+xYRidiArk1Yum4rd7z1FY1rV+XWkztEXRKggBARSQm/7NeaJWu38Oi4+TSqlc3gvq2iLkkBISKSCsyMP53akaXrtnLb67NpVCub/p0aRVqTOusTEUkR6WnG/ed1o2uz2lw3ajr5C9eUvFISKSBERFJIMNhQTxrXrsplT+bzTYSDDSkgRERSTN2cLJ4Y3JN0My4eNoUVG7ZGUocCQkQkBbWol8OwQT1ZvXE7lz6Rz6ZtZT/YkAJCRCRFdWlWmwd/0Y1ZS9Zx1TOflvlgQwoIEZEUdmyHBtx+eic+mrOS//m/L8p0sCFd5ioikuLO792CpWu38uCH82hUqyrXHdeuTLargBARKQduPKE9S9Zt4d73vqZR7WzOyWtW8kr7SQEhIlIOmBl3/LwzKzds43ejZ9KgZjZHtk/uGDg6ByEiUk5kZaTx8Pndad+gBlc+NY0vvk/uYEMKCBGRcqRGdiZPDO5JraqZDH5iKovWbE7athQQIiLlTIOa2TxxSS+27Shk0PAprN28PSnbUUCIiJRD7RvU4NGL8li0ZguXP5nP1h2lP9iQAkJEpJzq07oe/zynC21yq5OehEGGdBWTiEg5dmqXxpzapXFSnltHECIiEpcCQkRE4lJAiIhIXAoIERGJSwEhIiJxKSBERCQuBYSIiMSlgBARkbisLEcnSjYzWwl8G3Ud+6k+sCrqIlKE9sVPaX/8lPbHj/ZnX7Rw97j9hleogKgIzCzf3fOiriMVaF/8lPbHT2l//ChZ+0JNTCIiEpcCQkRE4lJApJ5Hoy4ghWhf/JT2x09pf/woKftC5yBERCQuHUGIiEhcCggREYlLAZECzKyZmX1oZl+a2Swzuy7qmqJmZulm9pmZvR51LVEzs9pm9qKZfRX+jRwadU1RMrMbwv+TL8zsWTPLjrqmsmRmw8xshZl9ETOtrpm9a2Zzw+91SmNbCojUUADc6O4dgD7AVWZ2cMQ1Re064Muoi0gR9wFvu/tBQBcq8X4xsybAtUCeu3cC0oHzoq2qzD0B9C827RbgfXdvB7wfPt5vCogU4O5L3f3T8OcNBG8ATaKtKjpm1hT4GfBY1LVEzcxqAv2AxwHcfbu7r420qOhlAFXNLAOoBiyJuJ4y5e7jgDXFJg8ARoQ/jwBOL41tKSBSjJm1BLoBn0RcSpT+BfwW2BlxHamgNbASGB42uT1mZjlRFxUVd/8euBv4DlgKrHP3MdFWlRIauPtSCD5wAgeUxpMqIFKImVUHXgKud/f1UdcTBTM7BVjh7tOiriVFZADdgX+7ezdgE6XUfFAehW3rA4BWQGMgx8wuiLaqiksBkSLMLJMgHJ5299FR1xOhvsBpZrYQGAUcY2ZPRVtSpBYDi9296IjyRYLAqKyOAxa4+0p33wGMBg6LuKZUsNzMGgGE31eUxpMqIFKAmRlBG/OX7n5P1PVEyd1/5+5N3b0lwcnHD9y90n5CdPdlwCIzOzCcdCwwO8KSovYd0MfMqoX/N8dSiU/ax3gVuDj8+WLgldJ40ozSeBLZb32BC4GZZjY9nHaru78ZXUmSQq4BnjazLGA+MDjieiLj7p+Y2YvApwRX/31GJetyw8yeBY4C6pvZYuBPwB3A82Z2KUGInl0q21JXGyIiEo+amEREJC4FhIiIxKWAEBGRuBQQIiISlwJCRETiUkBIhWZmhWY2Pear5T48x+nJ7DzRzNqb2ZtmNi/srfV5M2tQyttI6muQikkBIRXdFnfvGvO1cB+e43Rgr95cw47kElkuG3iDoCuNtmGPvv8Gcve2yBKczl6+BhEFhFQ6ZtbDzMaa2TQzeyemi4LLzWyqmc0ws5fCu3UPA04D7gqPQNqY2UdmlheuUz/sFgQzG2RmL5jZa8AYM8sJ++6fGna0NyBOOb8AJrn7a0UT3P1Dd//CzLLNbLiZzQzXPzpmOw/GvJ7Xzeyo8OeNZva38DVMNrMG8V5D6e9VqYgUEFLRVY1pXno57PPqAeAsd+8BDAP+Fi472t17unvRmAuXuvvHBN0Y3BQegXxTwvYOBS5292OA3xN0FdITOJrgDbp4T6ydgN11THgVgLsfAgwERiQwOE4OMDl8DeOAy/fhNYgA6mpDKr4t7t616IGZdSJ4U3436MqHdIJuowE6mdlfgdpAdeCdfdjeu+5e1Ff/CQQdD/4mfJwNNCfxvoMOJwgz3P0rM/sWaF/COtuBolH4pgHHJ1q4SHEKCKlsDJjl7vGG7XwCON3dZ5jZIIL+buIp4Mej7+Kf6DcV29aZ7j5nD/XMAo7cQ60lbb94DTv8x/5zCtH/uOwHNTFJZTMHyC0a19nMMs2sYzivBrA0bIY6P2adDeG8IguBHuHPZ+1hW+8A14S9jmJm3eIs8wxwmJn9rGiCmfU3s0MImojOD6e1Jzj6mBNuv6uZpZlZM6BXSS86zmsQKZECQioVd99O8KZ+p5nNAKbz43gCfyAYye9d4KuY1UYBN4UnitsQjGj2KzP7GKi/h83dDmQCn1swwPztcerZApxCECRzzWw2MIigP/+HgXQzmwk8Bwxy923ARGABMDOs5dMEXnrx1yBSIvXmKiIicekIQkRE4lJAiIhIXAoIERGJSwEhIiJxKSBERCQuBYSIiMSlgBARkbj+H/AVLkN4VwNaAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Execution time  12730.3 seconds\n",
      "\n",
      "\n",
      "Press 11 to run Forward Selection with small dataset\n",
      "Press 12 to run Forward Selection with large dataset\n",
      "Press 21 to run Backward Elimination with small dataset\n",
      "Press 22 to run Backward Elimination with large dataset\n",
      "Press any other key to exit\n",
      "exit\n",
      "Exit. Thank you\n"
     ]
    }
   ],
   "source": [
    "# driver function\n",
    "if __name__ == \"__main__\":\n",
    "    \n",
    "#     small_dataset_path = 'CS205_CalibrationData__1.txt'\n",
    "    \n",
    "    small_dataset_path = 'CS205_SP_2022_SMALLtestdata__35.txt'\n",
    "    large_dataset_path = 'CS205_SP_2022_Largetestdata__62.txt'\n",
    "    \n",
    "    while True:\n",
    "\n",
    "        input_case = input('Press 11 to run Forward Selection with small dataset\\n' + \\\n",
    "                          'Press 12 to run Forward Selection with large dataset\\n' + \\\n",
    "                          'Press 21 to run Backward Elimination with small dataset\\n' + \\\n",
    "                          'Press 22 to run Backward Elimination with large dataset\\n' + \\\n",
    "                          'Press any other key to exit\\n').strip()\n",
    "        \n",
    "        start_time = time.time()\n",
    "        \n",
    "        if input_case == '11':\n",
    "            print(\"Forward Selection selected with small dataset\")\n",
    "            instances, instance_count, feature_count = read_dataset(small_dataset_path)\n",
    "            \n",
    "            accuracy_map = start_experiment(instances, instance_count, \\\n",
    "                                            feature_count, FORWARD_SELECTION)\n",
    "            plot_graph(accuracy_map, FORWARD_SELECTION, 'small')\n",
    "                \n",
    "        elif input_case == '12':\n",
    "            print(\"Forward Selection selected with large dataset\")\n",
    "            instances, instance_count, feature_count = read_dataset(large_dataset_path)\n",
    "            \n",
    "            accuracy_map = start_experiment(instances, instance_count, \\\n",
    "                                            feature_count, FORWARD_SELECTION)\n",
    "            plot_graph(accuracy_map, FORWARD_SELECTION, 'large')\n",
    "            \n",
    "            \n",
    "        elif input_case == '21':\n",
    "            print('Backward Elimination selected with small dataset')\n",
    "            instances, instance_count, feature_count = read_dataset(small_dataset_path)\n",
    "            \n",
    "            accuracy_map = start_experiment(instances, instance_count, \\\n",
    "                                            feature_count, BACKWARD_ELIMINATION)\n",
    "            plot_graph(accuracy_map, BACKWARD_ELIMINATION, 'small')\n",
    "            \n",
    "            \n",
    "        elif input_case == '22':\n",
    "            print('Backward Elimination selected with large dataset')\n",
    "            \n",
    "            instances, instance_count, feature_count = read_dataset(large_dataset_path)\n",
    "            \n",
    "            accuracy_map = start_experiment(instances, instance_count, \\\n",
    "                                            feature_count, BACKWARD_ELIMINATION)\n",
    "            plot_graph(accuracy_map, BACKWARD_ELIMINATION, 'large')\n",
    "            \n",
    "            \n",
    "        else:\n",
    "            print('Exit. Thank you')\n",
    "            break\n",
    "        \n",
    "        end_time = time.time()\n",
    "        execution_time_in_seconds = end_time - start_time\n",
    "        print('Execution time ', '{:0.1f} seconds'.format(execution_time_in_seconds))\n",
    "        \n",
    "        print()\n",
    "        print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "380aed94",
   "metadata": {
    "id": "380aed94"
   },
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "name": "Feature_Selection.ipynb",
   "provenance": []
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}