code_03_feature_selection.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -------------------------------------------------%\n",
    "# Created by Safwan Mahmood Al-Selwi - 22/08/2024  %\n",
    "# Email:     saf1.alselwi@gmail.com                %\n",
    "# Github:    https://github.com/SafwanAlselwi      %\n",
    "# -------------------------------------------------%\n",
    "\n",
    "# Please consider citing our work if you find it useful:\n",
    "# Al-Selwi, S. M., Hassan, M. F., Abdulkadir, S. J., & et al. (2024). \n",
    "# Smart Grid Stability Prediction Using Adaptive Aquila Optimizer and Ensemble Stacked BiLSTM. Results in Engineering, 24, 103261. \n",
    "# doi: https://doi.org/10.1016/j.rineng.2024.103261."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UA4N0O2ZBbe8"
   },
   "source": [
    "[MAFESE (Metaheuristic Algorithms for FEature SElection)](https://github.com/thieu1995/mafese)\n",
    "\n",
    "[Documentation](https://mafese.readthedocs.io/en/latest/pages/mafese.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "TOgMp3UgFxiH",
    "outputId": "3f4a3c1a-4c3f-48b6-945e-621fa559a977"
   },
   "outputs": [],
   "source": [
    "# !pip install mafese==0.1.9\n",
    "# !pip install mealpy==2.5.4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Importing Libraries**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "id": "19PQwcQqZY3-"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import mafese\n",
    "from mafese.wrapper.mha import MhaSelector, MultiMhaSelector\n",
    "from mafese import Data\n",
    "\n",
    "from imblearn.over_sampling import SMOTE\n",
    "\n",
    "import time\n",
    "import os\n",
    "import datetime\n",
    "import statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.1.9'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mafese.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "epoch = 10\n",
    "pop_size = 10\n",
    "\n",
    "optimizer=\"AdaptiveAO\"\n",
    "optimizer_paras = {\"name\": optimizer, \"epoch\": epoch, \"pop_size\": pop_size, \"sharpness\":10.0, \"sigmoid_midpoint\":0.5}\n",
    "\n",
    "dataset = \"smart_grid_fs\"\n",
    "problem = \"classification\"\n",
    "\n",
    "ESTIMATOR = \"knn\"\n",
    "ESTIMATOR_PARAS = {\"n_neighbors\": 5,  \"weights\": \"uniform\",  \"algorithm\": \"auto\",  \"leaf_size\": 30,  \"p\": 2,  \"metric\": \"minkowski\",  \"metric_params\": None,  \"n_jobs\": None}\n",
    "\n",
    "base_path = \"\"\n",
    "\n",
    "def get_dataset_csv(dataset_name):\n",
    "  data_type = \"CLASSIFICATION\"\n",
    "  df = pd.read_csv(f\"{base_path}{dataset_name}.csv\", header=None)\n",
    "  X = np.array(df.iloc[:, 0:-1])\n",
    "  y = np.array(df.iloc[:, -1])\n",
    "      \n",
    "  if dataset_name in (\"smart_grid_fs_a\",\"smart_grid_fs\"):\n",
    "    X, y = SMOTE(random_state=42).fit_resample(X, y)\n",
    "  elif dataset_name in (\"PenglungEW\", \"Lymphography\", \"Arrhythmia\"):\n",
    "    X, y = SMOTE(k_neighbors=1).fit_resample(X, y)\n",
    "  # else:\n",
    "  #   X, y = SMOTE().fit_resample(X, y)\n",
    "\n",
    "  data = Data(X, y)\n",
    "\n",
    "  print(f\"Requested {data_type} dataset: {dataset_name} found and loaded from CSV\")\n",
    "  return data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Run Single Algorithm**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requested CLASSIFICATION dataset: smart_grid_fs found and loaded from CSV\n",
      "[ True  True  True  True False False False  True  True  True  True  True]\n",
      "[1 1 1 1 0 0 0 1 1 1 1 1]\n",
      "[ 0  1  2  3  7  8  9 10 11]\n",
      "{'dataset': 'smart_grid_fs', 'optimizer': 'AdaptiveAO', 'features': 12, 'AS_train': 0.90909, 'PS_train': 0.91575, 'RS_train': 0.91487, 'F1S_train': 0.9148, 'AS_test': 0.90909, 'PS_test': 0.91091, 'RS_test': 0.90909, 'F1S_test': 0.90915, 'time': 17.568374156951904}\n"
     ]
    }
   ],
   "source": [
    "# This function runs a single instance of a feature selection algorithm\n",
    "def run_single_algorithm():\n",
    "    # define mafese feature selection method\n",
    "    feat_selector = MhaSelector(problem = problem,\n",
    "                            estimator = ESTIMATOR,\n",
    "                            estimator_paras = ESTIMATOR_PARAS,\n",
    "                            optimizer = optimizer,\n",
    "                            optimizer_paras = optimizer_paras,\n",
    "                            transfer_func=\"vstf_01\",\n",
    "                            obj_name=\"AS\")\n",
    "\n",
    "   \n",
    "    output = {}\n",
    "    start_time = time.time()\n",
    "    \n",
    "    data = get_dataset_csv(dataset)\n",
    "    data.split_train_test(test_size=0.2, random_state=10)\n",
    "    \n",
    "    # Feature selection (find all relevant features)\n",
    "    feat_selector.fit(data.X_train, data.y_train, fit_weights=(0.9, 0.1), verbose=False)\n",
    "\n",
    "    # check selected features - True (or 1) is selected, False (or 0) is not selected\n",
    "    print(feat_selector.selected_feature_masks)\n",
    "    print(feat_selector.selected_feature_solution)\n",
    "    print(feat_selector.selected_feature_indexes)\n",
    "\n",
    "    # Evaluate final dataset with different estimator with multiple performance metrics\n",
    "    results = feat_selector.evaluate(estimator=\"svm\", data=data, metrics=[\"AS\", \"PS\", \"RS\",\"F1S\", \"SS\", \"CEL\"])\n",
    "\n",
    "    execution_time = time.time() - start_time\n",
    "\n",
    "    # Initialize and populate the output dictionary\n",
    "    output = {\n",
    "        'dataset': dataset,\n",
    "        'optimizer': optimizer,\n",
    "        'features': len(feat_selector.selected_feature_solution),\n",
    "        'AS_train': results.get(\"AS_test\"),\n",
    "        'PS_train': results.get(\"PS_train\"),\n",
    "        'RS_train': results.get(\"RS_train\"),\n",
    "        'F1S_train': results.get(\"F1S_train\"),\n",
    "        'AS_test': results.get(\"AS_test\"),\n",
    "        'PS_test': results.get(\"PS_test\"),\n",
    "        'RS_test': results.get(\"RS_test\"),\n",
    "        'F1S_test': results.get(\"F1S_test\"),\n",
    "        'time': execution_time\n",
    "    }\n",
    "            \n",
    "    print(output)\n",
    "\n",
    "run_single_algorithm()\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "mafese",
   "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}