{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sebastian Raschka, 2015-2022   \n",
    "`mlxtend`, a library of extension and helper modules for Python's data analysis and machine learning libraries\n",
    "\n",
    "- GitHub repository: https://github.com/rasbt/mlxtend\n",
    "- Documentation: https://rasbt.github.io/mlxtend/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Author: Sebastian Raschka\n",
      "\n",
      "Last updated: 2023-05-17\n",
      "\n",
      "Python implementation: CPython\n",
      "Python version       : 3.9.16\n",
      "IPython version      : 8.13.2\n",
      "\n",
      "matplotlib: 3.7.1\n",
      "numpy     : 1.24.3\n",
      "scipy     : 1.10.1\n",
      "mlxtend   : 0.23.0.dev0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%load_ext watermark\n",
    "%watermark -a 'Sebastian Raschka' -u -d -v -p matplotlib,numpy,scipy,mlxtend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SequentialFeatureSelector: The popular forward and backward feature selection approaches (including floating variants)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implementation of *sequential feature algorithms* (SFAs) -- greedy search algorithms -- that have been developed as a suboptimal solution to the computationally often not feasible exhaustive search."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> from mlxtend.feature_selection import SequentialFeatureSelector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sequential feature selection algorithms are a family of greedy search algorithms that are used to reduce an initial *d*-dimensional feature space to a *k*-dimensional feature subspace where *k < d*. The motivation behind feature selection algorithms is to automatically select a subset of features most relevant to the problem. The goal of feature selection is two-fold: We want to improve the computational efficiency and reduce the model's generalization error by removing irrelevant features or noise. In addition, a wrapper approach such as sequential feature selection is advantageous if embedded feature selection -- for example, a regularization penalty like LASSO -- is not applicable.\n",
    "\n",
    "In a nutshell, SFAs remove or add one feature at a time based on the classifier performance until a feature subset of the desired size *k* is reached. There are four different flavors of SFAs available via the `SequentialFeatureSelector`:\n",
    "\n",
    "1. Sequential Forward Selection (SFS)\n",
    "2. Sequential Backward Selection (SBS)\n",
    "3. Sequential Forward Floating Selection (SFFS)\n",
    "4. Sequential Backward Floating Selection (SBFS)\n",
    "\n",
    "The ***floating*** variants, SFFS and SBFS, can be considered extensions to the simpler SFS and SBS algorithms. The floating algorithms have an additional exclusion or inclusion step to remove features once they were included (or excluded) so that a larger number of feature subset combinations can be sampled. It is important to emphasize that this step is conditional and only occurs if the resulting feature subset is assessed as \"better\" by the criterion function after the removal (or addition) of a particular feature. Furthermore, I added an optional check to skip the conditional exclusion steps if the algorithm gets stuck in cycles.  \n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "How is this different from *Recursive Feature Elimination* (RFE)  -- e.g., as implemented in `sklearn.feature_selection.RFE`? RFE is computationally less complex using the feature weight coefficients (e.g., linear models) or feature importance (tree-based algorithms) to eliminate features recursively, whereas SFSs eliminate (or add) features based on a user-defined classifier/regression performance metric.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial Videos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/0vCXcGJg5Bo\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/KYypVSwqqHI\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visual Illustration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A visual illustration of the sequential backward selection process is provided below, from the paper\n",
    "\n",
    "- Joe Bemister-Buffington, Alex J. Wolf, Sebastian Raschka, and Leslie A. Kuhn (2020)\n",
    "Machine Learning to Identify Flexibility Signatures of Class A GPCR Inhibition\n",
    "Biomolecules 2020, 10, 454. https://www.mdpi.com/2218-273X/10/3/454#\n",
    "\n",
    "![](SequentialFeatureSelector_files/sbs-gpcr2020.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algorithmic Details"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sequential Forward Selection (SFS)\n",
    "\n",
    "\n",
    "**Input:** $Y = \\{y_1, y_2, ..., y_d\\}$  \n",
    "\n",
    "- The ***SFS*** algorithm takes the whole $d$-dimensional feature set as input.\n",
    "\n",
    "\n",
    "**Output:** $X_k = \\{x_j \\; | \\;j = 1, 2, ..., k; \\; x_j \\in Y\\}$, where $k = (0, 1, 2, ..., d)$\n",
    "\n",
    "- SFS returns a subset of features; the number of selected features $k$, where $k < d$, has to be specified *a priori*.\n",
    "\n",
    "**Initialization:** $X_0 = \\emptyset$, $k = 0$\n",
    "\n",
    "- We initialize the algorithm with an empty set $\\emptyset$ (\"null set\") so that $k = 0$ (where $k$ is the size of the subset).\n",
    "\n",
    "**Step 1 (Inclusion):**  \n",
    "\n",
    "  $x^+ = \\text{ arg max } J(X_k + x), \\text{ where }  x \\in Y - X_k$  \n",
    "  $X_{k+1} = X_k + x^+$  \n",
    "  $k = k + 1$    \n",
    "  *Go to Step 1* \n",
    "\n",
    "- in this step, we add an additional feature, $x^+$, to our feature subset $X_k$.\n",
    "- $x^+$ is the feature that maximizes our criterion function, that is, the feature that is associated with the best classifier performance if it is added to $X_k$.\n",
    "- We repeat this procedure until the termination criterion is satisfied.\n",
    "\n",
    "**Termination:** $k = p$\n",
    "\n",
    "- We add features from the feature subset $X_k$ until the feature subset of size $k$ contains the number of desired features $p$ that we specified *a priori*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sequential Backward Selection (SBS)\n",
    "\n",
    "**Input:** the set of all features, $Y = \\{y_1, y_2, ..., y_d\\}$  \n",
    "\n",
    "- The SBS algorithm takes the whole feature set as input.\n",
    "\n",
    "**Output:** $X_k = \\{x_j \\; | \\;j = 1, 2, ..., k; \\; x_j \\in Y\\}$, where $k = (0, 1, 2, ..., d)$\n",
    "\n",
    "- SBS returns a subset of features; the number of selected features $k$, where $k < d$, has to be specified *a priori*.\n",
    "\n",
    "**Initialization:** $X_0 = Y$, $k = d$\n",
    "\n",
    "- We initialize the algorithm with the given feature set so that the $k = d$.\n",
    "\n",
    "\n",
    "**Step 1 (Exclusion):**  \n",
    "\n",
    "$x^- = \\text{ arg max } J(X_k - x), \\text{  where } x \\in X_k$  \n",
    "$X_{k-1} = X_k - x^-$  \n",
    "$k = k - 1$  \n",
    "*Go to Step 1*  \n",
    "\n",
    "- In this step, we remove a feature, $x^-$ from our feature subset $X_k$.\n",
    "- $x^-$ is the feature that maximizes our criterion function upon re,oval, that is, the feature that is associated with the best classifier performance if it is removed from $X_k$.\n",
    "- We repeat this procedure until the termination criterion is satisfied.\n",
    "\n",
    "\n",
    "**Termination:** $k = p$\n",
    "\n",
    "- We add features from the feature subset $X_k$ until the feature subset of size $k$ contains the number of desired features $p$ that we specified *a priori*.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sequential Backward Floating Selection (SBFS)\n",
    "\n",
    "**Input:** the set of all features, $Y = \\{y_1, y_2, ..., y_d\\}$  \n",
    "\n",
    "- The SBFS algorithm takes the whole feature set as input.\n",
    "\n",
    "**Output:** $X_k = \\{x_j \\; | \\;j = 1, 2, ..., k; \\; x_j \\in Y\\}$, where $k = (0, 1, 2, ..., d)$\n",
    "\n",
    "- SBFS returns a subset of features; the number of selected features $k$, where $k < d$, has to be specified *a priori*.\n",
    "\n",
    "**Initialization:** $X_0 = Y$, $k = d$\n",
    "\n",
    "- We initialize the algorithm with the given feature set so that the $k = d$.\n",
    "\n",
    "**Step 1 (Exclusion):**  \n",
    "\n",
    "$x^- = \\text{ arg max } J(X_k - x), \\text{  where } x \\in X_k$  \n",
    "$X_{k-1} = X_k - x^-$  \n",
    "$k = k - 1$  \n",
    "*Go to Step 2*  \n",
    "\n",
    "- In this step, we remove a feature, $x^-$ from our feature subset $X_k$.\n",
    "- $x^-$ is the feature that maximizes our criterion function upon removal, that is, the feature that is associated with the best classifier performance if it is removed from $X_k$.\n",
    "\n",
    "\n",
    "**Step 2 (Conditional Inclusion):**  \n",
    "<br>\n",
    "$x^+ = \\text{ arg max } J(X_k + x), \\text{ where } x \\in Y - X_k$  \n",
    "*if J(X_k + x) > J(X_k)*:    \n",
    "&nbsp;&nbsp;&nbsp;&nbsp; $X_{k+1} = X_k + x^+$  \n",
    "&nbsp;&nbsp;&nbsp;&nbsp; $k = k + 1$  \n",
    "*Go to Step 1*  \n",
    "\n",
    "- In Step 2, we search for features that improve the classifier performance if they are added back to the feature subset. If such features exist, we add the feature $x^+$ for which the performance improvement is maximized. If $k = 2$ or an improvement cannot be made (i.e., such feature $x^+$ cannot be found), go back to step 1; else, repeat this step.\n",
    "\n",
    "\n",
    "**Termination:** $k = p$\n",
    "\n",
    "- We add features from the feature subset $X_k$ until the feature subset of size $k$ contains the number of desired features $p$ that we specified *a priori*.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sequential Forward Floating Selection (SFFS)\n",
    "\n",
    "**Input:** the set of all features, $Y = \\{y_1, y_2, ..., y_d\\}$  \n",
    "\n",
    "- The ***SFFS*** algorithm takes the whole feature set as input, if our feature space consists of, e.g. 10, if our feature space consists of 10 dimensions (***d = 10***).\n",
    "<br><br>\n",
    "\n",
    "**Output:** a subset of features, $X_k = \\{x_j \\; | \\;j = 1, 2, ..., k; \\; x_j \\in Y\\}$, where $k = (0, 1, 2, ..., d)$\n",
    "\n",
    "- The returned output of the algorithm is a subset of the feature space of a specified size. E.g., a subset of 5 features from a 10-dimensional feature space (***k = 5, d = 10***).\n",
    "<br><br>\n",
    "\n",
    "**Initialization:** $X_0 = \\emptyset$, $k = 0$\n",
    "\n",
    "- We initialize the algorithm with an empty set (\"null set\") so that the ***k = 0*** (where ***k*** is the size of the subset)\n",
    "<br><br>\n",
    "\n",
    "**Step 1 (Inclusion):**  \n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp; $x^+ = \\text{ arg max } J(X_k + x), \\text{ where }  x \\in Y - X_k$  \n",
    "&nbsp;&nbsp;&nbsp;&nbsp; $X_{k+1} = X_k + x^+$  \n",
    "&nbsp;&nbsp;&nbsp;&nbsp; $k = k + 1$    \n",
    "&nbsp;&nbsp;&nbsp;&nbsp;*Go to Step 2*  \n",
    "<br> <br>\n",
    "**Step 2 (Conditional Exclusion):**  \n",
    "<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp; $x^- = \\text{ arg max } J(X_k - x), \\text{ where } x \\in X_k$  \n",
    "&nbsp;&nbsp;&nbsp;&nbsp;$if \\; J(X_k - x) > J(X_k)$:    \n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; $X_{k-1} = X_k - x^- $  \n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; $k = k - 1$    \n",
    "&nbsp;&nbsp;&nbsp;&nbsp;*Go to Step 1*  \n",
    "\n",
    "- In step 1, we include the feature from the ***feature space*** that leads to the best performance increase for our ***feature subset*** (assessed by the ***criterion function***). Then, we go over to step 2\n",
    "- In step 2, we only remove a feature if the resulting subset would gain an increase in performance. If $k = 2$ or an improvement cannot be made (i.e., such feature $x^+$ cannot be found), go back to step 1; else, repeat this step.\n",
    "\n",
    "\n",
    "- Steps 1 and 2 are repeated until the **Termination** criterion is reached.\n",
    "<br><br>\n",
    "\n",
    "**Termination:** stop when ***k*** equals the number of desired features\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References\n",
    "\n",
    "- Ferri, F. J., Pudil P., Hatef, M., Kittler, J. (1994). [*\"Comparative study of techniques for large-scale feature selection.\"*](https://books.google.com/books?hl=en&lr=&id=sbajBQAAQBAJ&oi=fnd&pg=PA403&dq=comparative+study+of+techniques+for+large+scale&ots=KdIOYpA8wj&sig=hdOsBP1HX4hcDjx4RLg_chheojc#v=onepage&q=comparative%20study%20of%20techniques%20for%20large%20scale&f=false) Pattern Recognition in Practice IV : 403-413.\n",
    "\n",
    "- Pudil, P., Novovičová, J., & Kittler, J. (1994). [*\"Floating search methods in feature selection.\"*](https://www.sciencedirect.com/science/article/pii/0167865594901279) Pattern recognition letters 15.11 (1994): 1119-1125."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 1 - A simple Sequential Forward Selection example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initializing a simple classifier from scikit-learn:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.datasets import load_iris\n",
    "\n",
    "iris = load_iris()\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "knn = KNeighborsClassifier(n_neighbors=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start by selection the \"best\" 3 features from the Iris dataset via Sequential Forward Selection (SFS). Here, we set `forward=True` and `floating=False`. By choosing `cv=0`, we don't perform any cross-validation, therefore, the performance (here: `'accuracy'`) is computed entirely on the training set. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   4 out of   4 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:17] Features: 1/3 -- score: 0.96[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   3 out of   3 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:17] Features: 2/3 -- score: 0.9733333333333334[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:17] Features: 3/3 -- score: 0.9733333333333334"
     ]
    }
   ],
   "source": [
    "from mlxtend.feature_selection import SequentialFeatureSelector as SFS\n",
    "\n",
    "sfs1 = SFS(knn, \n",
    "           k_features=3, \n",
    "           forward=True, \n",
    "           floating=False, \n",
    "           verbose=2,\n",
    "           scoring='accuracy',\n",
    "           cv=0)\n",
    "\n",
    "sfs1 = sfs1.fit(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Via the `subsets_` attribute, we can take a look at the selected feature indices at each step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: {'feature_idx': (3,),\n",
       "  'cv_scores': array([0.96]),\n",
       "  'avg_score': 0.96,\n",
       "  'feature_names': ('3',)},\n",
       " 2: {'feature_idx': (2, 3),\n",
       "  'cv_scores': array([0.97333333]),\n",
       "  'avg_score': 0.9733333333333334,\n",
       "  'feature_names': ('2', '3')},\n",
       " 3: {'feature_idx': (1, 2, 3),\n",
       "  'cv_scores': array([0.97333333]),\n",
       "  'avg_score': 0.9733333333333334,\n",
       "  'feature_names': ('1', '2', '3')}}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sfs1.subsets_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   4 out of   4 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:17] Features: 1/3 -- score: 0.96[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   3 out of   3 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:17] Features: 2/3 -- score: 0.9733333333333334[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:17] Features: 3/3 -- score: 0.9733333333333334"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1: {'feature_idx': (3,),\n",
       "  'cv_scores': array([0.96]),\n",
       "  'avg_score': 0.96,\n",
       "  'feature_names': ('3',)},\n",
       " 2: {'feature_idx': (2, 3),\n",
       "  'cv_scores': array([0.97333333]),\n",
       "  'avg_score': 0.9733333333333334,\n",
       "  'feature_names': ('2', '3')},\n",
       " 3: {'feature_idx': (1, 2, 3),\n",
       "  'cv_scores': array([0.97333333]),\n",
       "  'avg_score': 0.9733333333333334,\n",
       "  'feature_names': ('1', '2', '3')}}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sfs1 = sfs1.fit(X, y)\n",
    "sfs1.subsets_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Furthermore, we can access the indices of the 3 best features directly via the `k_feature_idx_` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sfs1.k_feature_idx_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, the prediction score for these 3 features can be accesses via `k_score_`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9733333333333334"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sfs1.k_score_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Feature Names**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When working with large datasets, the feature indices might be hard to interpret. In this case, we recommend using pandas DataFrames with distinct column names as input:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Sepal length</th>\n",
       "      <th>Sepal width</th>\n",
       "      <th>Petal length</th>\n",
       "      <th>Petal width</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Sepal length  Sepal width  Petal length  Petal width\n",
       "0           5.1          3.5           1.4          0.2\n",
       "1           4.9          3.0           1.4          0.2\n",
       "2           4.7          3.2           1.3          0.2\n",
       "3           4.6          3.1           1.5          0.2\n",
       "4           5.0          3.6           1.4          0.2"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df_X = pd.DataFrame(X, columns=[\"Sepal length\", \"Sepal width\", \"Petal length\", \"Petal width\"])\n",
    "df_X.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best accuracy score: 0.97\n",
      "Best subset (indices): (1, 2, 3)\n",
      "Best subset (corresponding names): ('Sepal width', 'Petal length', 'Petal width')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   4 out of   4 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:17] Features: 1/3 -- score: 0.96[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   3 out of   3 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:17] Features: 2/3 -- score: 0.9733333333333334[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:17] Features: 3/3 -- score: 0.9733333333333334"
     ]
    }
   ],
   "source": [
    "sfs1 = sfs1.fit(df_X, y)\n",
    "\n",
    "print('Best accuracy score: %.2f' % sfs1.k_score_)\n",
    "print('Best subset (indices):', sfs1.k_feature_idx_)\n",
    "print('Best subset (corresponding names):', sfs1.k_feature_names_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 2 - Toggling between SFS, SBS, SFFS, and SBFS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the `forward` and `floating` parameters, we can toggle between SFS, SBS, SFFS, and SBFS as shown below. Note that we are performing (stratified) 4-fold cross-validation for more robust estimates in contrast to Example 1. Via `n_jobs=-1`, we choose to run the cross-validation on all our available CPU cores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Sequential Forward Selection (k=3):\n",
      "(1, 2, 3)\n",
      "CV Score:\n",
      "0.9731507823613088\n",
      "\n",
      "Sequential Backward Selection (k=3):\n",
      "(1, 2, 3)\n",
      "CV Score:\n",
      "0.9731507823613088\n",
      "\n",
      "Sequential Forward Floating Selection (k=3):\n",
      "(1, 2, 3)\n",
      "CV Score:\n",
      "0.9731507823613088\n",
      "\n",
      "Sequential Backward Floating Selection (k=3):\n",
      "(1, 2, 3)\n",
      "CV Score:\n",
      "0.9731507823613088\n"
     ]
    }
   ],
   "source": [
    "# Sequential Forward Selection\n",
    "sfs = SFS(knn, \n",
    "          k_features=3, \n",
    "          forward=True, \n",
    "          floating=False, \n",
    "          scoring='accuracy',\n",
    "          cv=4,\n",
    "          n_jobs=-1)\n",
    "sfs = sfs.fit(X, y)\n",
    "\n",
    "print('\\nSequential Forward Selection (k=3):')\n",
    "print(sfs.k_feature_idx_)\n",
    "print('CV Score:')\n",
    "print(sfs.k_score_)\n",
    "\n",
    "###################################################\n",
    "\n",
    "# Sequential Backward Selection\n",
    "sbs = SFS(knn, \n",
    "          k_features=3, \n",
    "          forward=False, \n",
    "          floating=False, \n",
    "          scoring='accuracy',\n",
    "          cv=4,\n",
    "          n_jobs=-1)\n",
    "sbs = sbs.fit(X, y)\n",
    "\n",
    "print('\\nSequential Backward Selection (k=3):')\n",
    "print(sbs.k_feature_idx_)\n",
    "print('CV Score:')\n",
    "print(sbs.k_score_)\n",
    "\n",
    "###################################################\n",
    "\n",
    "# Sequential Forward Floating Selection\n",
    "sffs = SFS(knn, \n",
    "           k_features=3, \n",
    "           forward=True, \n",
    "           floating=True, \n",
    "           scoring='accuracy',\n",
    "           cv=4,\n",
    "           n_jobs=-1)\n",
    "sffs = sffs.fit(X, y)\n",
    "\n",
    "print('\\nSequential Forward Floating Selection (k=3):')\n",
    "print(sffs.k_feature_idx_)\n",
    "print('CV Score:')\n",
    "print(sffs.k_score_)\n",
    "\n",
    "###################################################\n",
    "\n",
    "# Sequential Backward Floating Selection\n",
    "sbfs = SFS(knn, \n",
    "           k_features=3, \n",
    "           forward=False, \n",
    "           floating=True, \n",
    "           scoring='accuracy',\n",
    "           cv=4,\n",
    "           n_jobs=-1)\n",
    "sbfs = sbfs.fit(X, y)\n",
    "\n",
    "print('\\nSequential Backward Floating Selection (k=3):')\n",
    "print(sbfs.k_feature_idx_)\n",
    "print('CV Score:')\n",
    "print(sbfs.k_score_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this simple scenario, selecting the best 3 features out of the 4 available features in the Iris set, we end up with similar results regardless of which sequential selection algorithms we used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 3 - Visualizing the results in DataFrames"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " For our convenience, we can visualize the output from the feature selection in a pandas DataFrame format using the `get_metric_dict` method of the SequentialFeatureSelector object. The columns `std_dev` and `std_err` represent the standard deviation and standard errors of the cross-validation scores, respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we see the DataFrame of the Sequential Forward Selector from Example 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>feature_idx</th>\n",
       "      <th>cv_scores</th>\n",
       "      <th>avg_score</th>\n",
       "      <th>feature_names</th>\n",
       "      <th>ci_bound</th>\n",
       "      <th>std_dev</th>\n",
       "      <th>std_err</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>(3,)</td>\n",
       "      <td>[0.9736842105263158, 0.9473684210526315, 0.918...</td>\n",
       "      <td>0.959993</td>\n",
       "      <td>(3,)</td>\n",
       "      <td>0.048319</td>\n",
       "      <td>0.030143</td>\n",
       "      <td>0.017403</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>(2, 3)</td>\n",
       "      <td>[0.9736842105263158, 0.9473684210526315, 0.918...</td>\n",
       "      <td>0.959993</td>\n",
       "      <td>(2, 3)</td>\n",
       "      <td>0.048319</td>\n",
       "      <td>0.030143</td>\n",
       "      <td>0.017403</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>(1, 2, 3)</td>\n",
       "      <td>[0.9736842105263158, 1.0, 0.9459459459459459, ...</td>\n",
       "      <td>0.973151</td>\n",
       "      <td>(1, 2, 3)</td>\n",
       "      <td>0.030639</td>\n",
       "      <td>0.019113</td>\n",
       "      <td>0.011035</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  feature_idx                                          cv_scores avg_score  \\\n",
       "1        (3,)  [0.9736842105263158, 0.9473684210526315, 0.918...  0.959993   \n",
       "2      (2, 3)  [0.9736842105263158, 0.9473684210526315, 0.918...  0.959993   \n",
       "3   (1, 2, 3)  [0.9736842105263158, 1.0, 0.9459459459459459, ...  0.973151   \n",
       "\n",
       "  feature_names  ci_bound   std_dev   std_err  \n",
       "1          (3,)  0.048319  0.030143  0.017403  \n",
       "2        (2, 3)  0.048319  0.030143  0.017403  \n",
       "3     (1, 2, 3)  0.030639  0.019113  0.011035  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "pd.DataFrame.from_dict(sfs.get_metric_dict()).T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's compare it to the Sequential Backward Selector:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>feature_idx</th>\n",
       "      <th>cv_scores</th>\n",
       "      <th>avg_score</th>\n",
       "      <th>feature_names</th>\n",
       "      <th>ci_bound</th>\n",
       "      <th>std_dev</th>\n",
       "      <th>std_err</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>(0, 1, 2, 3)</td>\n",
       "      <td>[0.9736842105263158, 0.9473684210526315, 0.918...</td>\n",
       "      <td>0.953236</td>\n",
       "      <td>(0, 1, 2, 3)</td>\n",
       "      <td>0.03602</td>\n",
       "      <td>0.022471</td>\n",
       "      <td>0.012974</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>(1, 2, 3)</td>\n",
       "      <td>[0.9736842105263158, 1.0, 0.9459459459459459, ...</td>\n",
       "      <td>0.973151</td>\n",
       "      <td>(1, 2, 3)</td>\n",
       "      <td>0.030639</td>\n",
       "      <td>0.019113</td>\n",
       "      <td>0.011035</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    feature_idx                                          cv_scores avg_score  \\\n",
       "4  (0, 1, 2, 3)  [0.9736842105263158, 0.9473684210526315, 0.918...  0.953236   \n",
       "3     (1, 2, 3)  [0.9736842105263158, 1.0, 0.9459459459459459, ...  0.973151   \n",
       "\n",
       "  feature_names  ci_bound   std_dev   std_err  \n",
       "4  (0, 1, 2, 3)   0.03602  0.022471  0.012974  \n",
       "3     (1, 2, 3)  0.030639  0.019113  0.011035  "
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame.from_dict(sbs.get_metric_dict()).T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that both SFS and SBFS found the same \"best\" 3 features, however, the intermediate steps where obviously different."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `ci_bound` column in the DataFrames above represents the confidence interval around the computed cross-validation scores. By default, a confidence interval of 95% is used, but we can use different confidence bounds via the `confidence_interval` parameter. E.g., the confidence bounds for a 90% confidence interval can be obtained as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>feature_idx</th>\n",
       "      <th>cv_scores</th>\n",
       "      <th>avg_score</th>\n",
       "      <th>feature_names</th>\n",
       "      <th>ci_bound</th>\n",
       "      <th>std_dev</th>\n",
       "      <th>std_err</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>(0, 1, 2, 3)</td>\n",
       "      <td>[0.9736842105263158, 0.9473684210526315, 0.918...</td>\n",
       "      <td>0.953236</td>\n",
       "      <td>(0, 1, 2, 3)</td>\n",
       "      <td>0.027658</td>\n",
       "      <td>0.022471</td>\n",
       "      <td>0.012974</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>(1, 2, 3)</td>\n",
       "      <td>[0.9736842105263158, 1.0, 0.9459459459459459, ...</td>\n",
       "      <td>0.973151</td>\n",
       "      <td>(1, 2, 3)</td>\n",
       "      <td>0.023525</td>\n",
       "      <td>0.019113</td>\n",
       "      <td>0.011035</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    feature_idx                                          cv_scores avg_score  \\\n",
       "4  (0, 1, 2, 3)  [0.9736842105263158, 0.9473684210526315, 0.918...  0.953236   \n",
       "3     (1, 2, 3)  [0.9736842105263158, 1.0, 0.9459459459459459, ...  0.973151   \n",
       "\n",
       "  feature_names  ci_bound   std_dev   std_err  \n",
       "4  (0, 1, 2, 3)  0.027658  0.022471  0.012974  \n",
       "3     (1, 2, 3)  0.023525  0.019113  0.011035  "
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame.from_dict(sbs.get_metric_dict(confidence_interval=0.90)).T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 4 - Plotting the results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After importing the little helper function [`plotting.plot_sequential_feature_selection`](../plotting/plot_sequential_feature_selection.md), we can also visualize the results using matplotlib figures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   4 out of   4 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:18] Features: 1/4 -- score: 0.96[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   3 out of   3 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:18] Features: 2/4 -- score: 0.9666666666666668[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:18] Features: 3/4 -- score: 0.9533333333333334[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:18] Features: 4/4 -- score: 0.9733333333333334"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mlxtend.plotting import plot_sequential_feature_selection as plot_sfs\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "sfs = SFS(knn, \n",
    "          k_features=4, \n",
    "          forward=True, \n",
    "          floating=False, \n",
    "          scoring='accuracy',\n",
    "          verbose=2,\n",
    "          cv=5)\n",
    "\n",
    "sfs = sfs.fit(X, y)\n",
    "\n",
    "fig1 = plot_sfs(sfs.get_metric_dict(), kind='std_dev')\n",
    "\n",
    "plt.ylim([0.8, 1])\n",
    "plt.title('Sequential Forward Selection (w. StdDev)')\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 5 - Sequential Feature Selection for Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to the classification examples above, the `SequentialFeatureSelector` also supports scikit-learn's estimators\n",
    "for regression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.datasets import fetch_california_housing\n",
    "\n",
    "data = fetch_california_housing()\n",
    "X, y = data.data, data.target\n",
    "\n",
    "lr = LinearRegression()\n",
    "\n",
    "sfs = SFS(lr, \n",
    "          k_features=8, \n",
    "          forward=True, \n",
    "          floating=False, \n",
    "          scoring='neg_mean_squared_error',\n",
    "          cv=10)\n",
    "\n",
    "sfs = sfs.fit(X, y)\n",
    "fig = plot_sfs(sfs.get_metric_dict(), kind='std_err')\n",
    "\n",
    "plt.title('Sequential Forward Selection (w. StdErr)')\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 6 -- Feature Selection with Fixed Train/Validation Splits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you do not wish to use cross-validation (here: k-fold cross-validation, i.e., rotating training and validation folds), you can use the `PredefinedHoldoutSplit` class to specify your own, fixed training and validation split."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 72 112 132  88  37 138  87  42   8  90 141  33  59 116 135 104  36  13\n",
      "  63  45  28 133  24 127  46  20  31 121 117   4]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from mlxtend.evaluate import PredefinedHoldoutSplit\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "iris = load_iris()\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "\n",
    "rng = np.random.RandomState(123)\n",
    "my_validation_indices = rng.permutation(np.arange(150))[:30]\n",
    "print(my_validation_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   4 out of   4 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:19] Features: 1/3 -- score: 0.9666666666666667[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   3 out of   3 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:19] Features: 2/3 -- score: 0.9666666666666667[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:36:19] Features: 3/3 -- score: 0.9666666666666667"
     ]
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from mlxtend.feature_selection import SequentialFeatureSelector as SFS\n",
    "\n",
    "\n",
    "\n",
    "knn = KNeighborsClassifier(n_neighbors=4)\n",
    "piter = PredefinedHoldoutSplit(my_validation_indices)\n",
    "\n",
    "sfs1 = SFS(knn, \n",
    "           k_features=3, \n",
    "           forward=True, \n",
    "           floating=False, \n",
    "           verbose=2,\n",
    "           scoring='accuracy',\n",
    "           cv=piter)\n",
    "\n",
    "sfs1 = sfs1.fit(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 7 -- Using the Selected Feature Subset For Making New Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize the dataset\n",
    "\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "iris = load_iris()\n",
    "X, y = iris.data, iris.target\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "         X, y, test_size=0.33, random_state=1)\n",
    "\n",
    "knn = KNeighborsClassifier(n_neighbors=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select the \"best\" three features via\n",
    "# 5-fold cross-validation on the training set.\n",
    "\n",
    "from mlxtend.feature_selection import SequentialFeatureSelector as SFS\n",
    "\n",
    "sfs1 = SFS(knn, \n",
    "           k_features=3, \n",
    "           forward=True, \n",
    "           floating=False, \n",
    "           scoring='accuracy',\n",
    "           cv=5)\n",
    "sfs1 = sfs1.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Selected features: (1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "print('Selected features:', sfs1.k_feature_idx_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test set accuracy: 96.00 %\n"
     ]
    }
   ],
   "source": [
    "# Generate the new subsets based on the selected features\n",
    "# Note that the transform call is equivalent to\n",
    "# X_train[:, sfs1.k_feature_idx_]\n",
    "\n",
    "X_train_sfs = sfs1.transform(X_train)\n",
    "X_test_sfs = sfs1.transform(X_test)\n",
    "\n",
    "# Fit the estimator using the new feature subset\n",
    "# and make a prediction on the test data\n",
    "knn.fit(X_train_sfs, y_train)\n",
    "y_pred = knn.predict(X_test_sfs)\n",
    "\n",
    "# Compute the accuracy of the prediction\n",
    "acc = float((y_test == y_pred).sum()) / y_pred.shape[0]\n",
    "print('Test set accuracy: %.2f %%' % (acc * 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 8 -- Sequential Feature Selection and GridSearch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following example, we are tuning the SFS's estimator using GridSearch. To avoid unwanted behavior or side-effects, it's recommended to use the estimator inside and outside of SFS as separate instances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize the dataset\n",
    "\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "iris = load_iris()\n",
    "X, y = iris.data, iris.target\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "         X, y, test_size=0.2, random_state=123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.pipeline import Pipeline\n",
    "from mlxtend.feature_selection import SequentialFeatureSelector as SFS\n",
    "import mlxtend\n",
    "\n",
    "knn1 = KNeighborsClassifier()\n",
    "knn2 = KNeighborsClassifier()\n",
    "\n",
    "sfs1 = SFS(estimator=knn1, \n",
    "           k_features=3,\n",
    "           forward=True, \n",
    "           floating=False, \n",
    "           scoring='accuracy',\n",
    "           cv=5)\n",
    "\n",
    "pipe = Pipeline([('sfs', sfs1), \n",
    "                 ('knn2', knn2)])\n",
    "\n",
    "param_grid = {\n",
    "    'sfs__k_features': [1, 2, 3],\n",
    "    'sfs__estimator__n_neighbors': [3, 4, 7], # inner knn\n",
    "    'knn2__n_neighbors': [3, 4, 7] # outer knn\n",
    "  }\n",
    "    \n",
    "gs = GridSearchCV(estimator=pipe, \n",
    "                  param_grid=param_grid, \n",
    "                  scoring='accuracy', \n",
    "                  n_jobs=1, \n",
    "                  cv=5,\n",
    "                  refit=False)\n",
    "\n",
    "# run gridearch\n",
    "gs = gs.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at the suggested hyperparameters below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for i in range(len(gs.cv_results_['params'])):\n",
    "    print(gs.cv_results_['params'][i], 'test acc.:', gs.cv_results_['mean_test_score'][i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The \"best\" parameters determined by GridSearch are ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best parameters via GridSearch {'knn2__n_neighbors': 7, 'sfs__estimator__n_neighbors': 3, 'sfs__k_features': 3}\n"
     ]
    }
   ],
   "source": [
    "print(\"Best parameters via GridSearch\", gs.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>Pipeline(steps=[(&#x27;sfs&#x27;,\n",
       "                 SequentialFeatureSelector(estimator=KNeighborsClassifier(n_neighbors=3),\n",
       "                                           k_features=(3, 3),\n",
       "                                           scoring=&#x27;accuracy&#x27;)),\n",
       "                (&#x27;knn2&#x27;, KNeighborsClassifier(n_neighbors=7))])</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" ><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">Pipeline</label><div class=\"sk-toggleable__content\"><pre>Pipeline(steps=[(&#x27;sfs&#x27;,\n",
       "                 SequentialFeatureSelector(estimator=KNeighborsClassifier(n_neighbors=3),\n",
       "                                           k_features=(3, 3),\n",
       "                                           scoring=&#x27;accuracy&#x27;)),\n",
       "                (&#x27;knn2&#x27;, KNeighborsClassifier(n_neighbors=7))])</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" ><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">sfs: SequentialFeatureSelector</label><div class=\"sk-toggleable__content\"><pre>SequentialFeatureSelector(estimator=KNeighborsClassifier(n_neighbors=3),\n",
       "                          k_features=(3, 3), scoring=&#x27;accuracy&#x27;)</pre></div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-3\" type=\"checkbox\" ><label for=\"sk-estimator-id-3\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">estimator: KNeighborsClassifier</label><div class=\"sk-toggleable__content\"><pre>KNeighborsClassifier(n_neighbors=3)</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-4\" type=\"checkbox\" ><label for=\"sk-estimator-id-4\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">KNeighborsClassifier</label><div class=\"sk-toggleable__content\"><pre>KNeighborsClassifier(n_neighbors=3)</pre></div></div></div></div></div></div></div></div><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-5\" type=\"checkbox\" ><label for=\"sk-estimator-id-5\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">KNeighborsClassifier</label><div class=\"sk-toggleable__content\"><pre>KNeighborsClassifier(n_neighbors=7)</pre></div></div></div></div></div></div></div>"
      ],
      "text/plain": [
       "Pipeline(steps=[('sfs',\n",
       "                 SequentialFeatureSelector(estimator=KNeighborsClassifier(n_neighbors=3),\n",
       "                                           k_features=(3, 3),\n",
       "                                           scoring='accuracy')),\n",
       "                ('knn2', KNeighborsClassifier(n_neighbors=7))])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe.set_params(**gs.best_params_).fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 9 -- Selecting the \"best\"  feature combination in a k-range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If `k_features` is set to to a tuple `(min_k, max_k)` (new in 0.4.2), the SFS will now select the best feature combination that it discovered by iterating from `k=1` to `max_k` (forward), or `max_k` to `min_k` (backward). The size of the returned feature subset is then within `max_k` to `min_k`, depending on which combination scored best during cross validation.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(150, 4)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "best combination (ACC: 0.992): (0, 1, 2, 3, 6, 8, 9, 10, 11, 12)\n",
      "\n",
      "all subsets:\n",
      " {1: {'feature_idx': (6,), 'cv_scores': array([0.84 , 0.64 , 0.84 , 0.8  , 0.875]), 'avg_score': 0.799, 'feature_names': ('6',)}, 2: {'feature_idx': (6, 9), 'cv_scores': array([0.92      , 0.88      , 1.        , 0.96      , 0.91666667]), 'avg_score': 0.9353333333333333, 'feature_names': ('6', '9')}, 3: {'feature_idx': (6, 9, 12), 'cv_scores': array([0.92      , 0.92      , 0.96      , 1.        , 0.95833333]), 'avg_score': 0.9516666666666665, 'feature_names': ('6', '9', '12')}, 4: {'feature_idx': (3, 6, 9, 12), 'cv_scores': array([0.96      , 0.96      , 0.96      , 1.        , 0.95833333]), 'avg_score': 0.9676666666666666, 'feature_names': ('3', '6', '9', '12')}, 5: {'feature_idx': (3, 6, 9, 10, 12), 'cv_scores': array([0.92, 0.96, 1.  , 1.  , 1.  ]), 'avg_score': 0.976, 'feature_names': ('3', '6', '9', '10', '12')}, 6: {'feature_idx': (2, 3, 6, 9, 10, 12), 'cv_scores': array([0.92, 0.96, 1.  , 0.96, 1.  ]), 'avg_score': 0.968, 'feature_names': ('2', '3', '6', '9', '10', '12')}, 7: {'feature_idx': (0, 2, 3, 6, 9, 10, 12), 'cv_scores': array([0.92, 0.92, 1.  , 1.  , 1.  ]), 'avg_score': 0.968, 'feature_names': ('0', '2', '3', '6', '9', '10', '12')}, 8: {'feature_idx': (0, 2, 3, 6, 8, 9, 10, 12), 'cv_scores': array([1.  , 0.92, 1.  , 1.  , 1.  ]), 'avg_score': 0.984, 'feature_names': ('0', '2', '3', '6', '8', '9', '10', '12')}, 9: {'feature_idx': (0, 2, 3, 6, 8, 9, 10, 11, 12), 'cv_scores': array([1.  , 0.92, 1.  , 1.  , 1.  ]), 'avg_score': 0.984, 'feature_names': ('0', '2', '3', '6', '8', '9', '10', '11', '12')}, 10: {'feature_idx': (0, 1, 2, 3, 6, 8, 9, 10, 11, 12), 'cv_scores': array([1.  , 0.96, 1.  , 1.  , 1.  ]), 'avg_score': 0.992, 'feature_names': ('0', '1', '2', '3', '6', '8', '9', '10', '11', '12')}}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mlxtend.feature_selection import SequentialFeatureSelector as SFS\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from mlxtend.data import wine_data\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.pipeline import make_pipeline\n",
    "\n",
    "X, y = wine_data()\n",
    "X_train, X_test, y_train, y_test= train_test_split(X, y, \n",
    "                                                   stratify=y,\n",
    "                                                   test_size=0.3,\n",
    "                                                   random_state=1)\n",
    "\n",
    "knn = KNeighborsClassifier(n_neighbors=2)\n",
    "\n",
    "sfs1 = SFS(estimator=knn, \n",
    "           k_features=(3, 10),\n",
    "           forward=True, \n",
    "           floating=False, \n",
    "           scoring='accuracy',\n",
    "           cv=5)\n",
    "\n",
    "pipe = make_pipeline(StandardScaler(), sfs1)\n",
    "\n",
    "pipe.fit(X_train, y_train)\n",
    "\n",
    "print('best combination (ACC: %.3f): %s\\n' % (sfs1.k_score_, sfs1.k_feature_idx_))\n",
    "print('all subsets:\\n', sfs1.subsets_)\n",
    "plot_sfs(sfs1.get_metric_dict(), kind='std_err');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 10 -- Using other cross-validation schemes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to standard k-fold and stratified k-fold, other cross validation schemes can be used with `SequentialFeatureSelector`. For example, `GroupKFold` or `LeaveOneOut` cross-validation from scikit-learn. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using GroupKFold with SequentialFeatureSelector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "groups: [ 0  0  0  0  0  0  0  0  0  0  1  1  1  1  1  1  1  1  1  1  2  2  2  2\n",
      "  2  2  2  2  2  2  3  3  3  3  3  3  3  3  3  3  4  4  4  4  4  4  4  4\n",
      "  4  4  5  5  5  5  5  5  5  5  5  5  6  6  6  6  6  6  6  6  6  6  7  7\n",
      "  7  7  7  7  7  7  7  7  8  8  8  8  8  8  8  8  8  8  9  9  9  9  9  9\n",
      "  9  9  9  9 10 10 10 10 10 10 10 10 10 10 11 11 11 11 11 11 11 11 11 11\n",
      " 12 12 12 12 12 12 12 12 12 12 13 13 13 13 13 13 13 13 13 13 14 14 14 14\n",
      " 14 14 14 14 14 14]\n"
     ]
    }
   ],
   "source": [
    "from mlxtend.feature_selection import SequentialFeatureSelector as SFS\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from mlxtend.data import iris_data\n",
    "from sklearn.model_selection import GroupKFold\n",
    "import numpy as np\n",
    "\n",
    "X, y = iris_data()\n",
    "groups = np.arange(len(y)) // 10\n",
    "print('groups: {}'.format(groups))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calling the `split()` method of a scikit-learn cross-validator object will return a generator that yields train, test splits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object _BaseKFold.split at 0x17c109580>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_gen = GroupKFold(4).split(X, y, groups)\n",
    "cv_gen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `cv` parameter of `SequentialFeatureSelector` must be either an `int` or an iterable yielding train, test splits. This iterable can be constructed by passing the train, test split generator to the built-in `list()` function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv = list(cv_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "best combination (ACC: 0.940): (2, 3)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "knn = KNeighborsClassifier(n_neighbors=2)\n",
    "sfs = SFS(estimator=knn, \n",
    "          k_features=2,\n",
    "          scoring='accuracy',\n",
    "          cv=cv)\n",
    "\n",
    "sfs.fit(X, y)\n",
    "\n",
    "print('best combination (ACC: %.3f): %s\\n' % (sfs.k_score_, sfs.k_feature_idx_))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Example 11 - Interrupting Long Runs for Intermediate Results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If your run is taking too long, it is possible to trigger a `KeyboardInterrupt` (e.g., ctrl+c on a Mac, or interrupting the cell in a Jupyter notebook) to obtain temporary results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Toy dataset**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import make_classification\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "\n",
    "X, y = make_classification(\n",
    "    n_samples=20000,\n",
    "    n_features=500,\n",
    "    n_informative=10,\n",
    "    n_redundant=40,\n",
    "    n_repeated=25,\n",
    "    n_clusters_per_class=5,\n",
    "    flip_y=0.05,\n",
    "    class_sep=0.5,\n",
    "    random_state=123,\n",
    ")\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    X, y, test_size=0.2, random_state=123\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Long run with interruption**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done 500 out of 500 | elapsed:    8.3s finished\n",
      "\n",
      "[2023-05-17 08:36:32] Features: 1/10 -- score: 0.5965[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done 499 out of 499 | elapsed:   13.8s finished\n",
      "\n",
      "[2023-05-17 08:36:45] Features: 2/10 -- score: 0.6256875000000001[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done 498 out of 498 | elapsed:   18.1s finished\n",
      "\n",
      "[2023-05-17 08:37:03] Features: 3/10 -- score: 0.642[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done 497 out of 497 | elapsed:   20.4s finished\n",
      "\n",
      "[2023-05-17 08:37:24] Features: 4/10 -- score: 0.6463125[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done 496 out of 496 | elapsed:   22.2s finished\n",
      "\n",
      "[2023-05-17 08:37:46] Features: 5/10 -- score: 0.6495000000000001[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.1s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done 495 out of 495 | elapsed:   26.1s finished\n",
      "\n",
      "[2023-05-17 08:38:12] Features: 6/10 -- score: 0.6514374999999999[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done 494 out of 494 | elapsed:   26.1s finished\n",
      "\n",
      "[2023-05-17 08:38:38] Features: 7/10 -- score: 0.6533749999999999[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done 493 out of 493 | elapsed:   25.3s finished\n",
      "\n",
      "[2023-05-17 08:39:04] Features: 8/10 -- score: 0.6545624999999999[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.1s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done 492 out of 492 | elapsed:   26.3s finished\n",
      "\n",
      "[2023-05-17 08:39:30] Features: 9/10 -- score: 0.6549375[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.1s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done 491 out of 491 | elapsed:   27.0s finished\n",
      "\n",
      "[2023-05-17 08:39:57] Features: 10/10 -- score: 0.6554374999999999"
     ]
    }
   ],
   "source": [
    "from mlxtend.feature_selection import SequentialFeatureSelector as SFS\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "model = LogisticRegression()\n",
    "\n",
    "sfs1 = SFS(model, \n",
    "           k_features=10, \n",
    "           forward=True, \n",
    "           floating=False, \n",
    "           verbose=2,\n",
    "           scoring='accuracy',\n",
    "           cv=5)\n",
    "\n",
    "sfs1 = sfs1.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Finalizing the fit**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the feature selection run hasn't finished, so certain attributes may not be available. In order to use the SFS instance, it is recommended to call `finalize_fit`, which will make SFS estimator appear as \"fitted\" process the temporary results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "sfs1.finalize_fit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(30, 128, 144, 160, 184, 229, 256, 356, 439, 458)\n",
      "0.6554374999999999\n"
     ]
    }
   ],
   "source": [
    "print(sfs1.k_feature_idx_)\n",
    "print(sfs1.k_score_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 12 - Using Pandas DataFrames"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Optionally, we can also use pandas DataFrames and pandas Series as input to the `fit` function. In this case, the column names of the pandas DataFrame will be used as feature names. However, note that if `custom_feature_names` are provided in the fit function, these `custom_feature_names` take precedence over the DataFrame column-based feature names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.datasets import load_iris\n",
    "from mlxtend.feature_selection import SequentialFeatureSelector as SFS\n",
    "\n",
    "\n",
    "iris = load_iris()\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "knn = KNeighborsClassifier(n_neighbors=4)\n",
    "\n",
    "sfs1 = SFS(knn, \n",
    "           k_features=3, \n",
    "           forward=True, \n",
    "           floating=False, \n",
    "           scoring='accuracy',\n",
    "           cv=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal len</th>\n",
       "      <th>petal len</th>\n",
       "      <th>sepal width</th>\n",
       "      <th>petal width</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal len  petal len  sepal width  petal width\n",
       "0        5.1        3.5          1.4          0.2\n",
       "1        4.9        3.0          1.4          0.2\n",
       "2        4.7        3.2          1.3          0.2\n",
       "3        4.6        3.1          1.5          0.2\n",
       "4        5.0        3.6          1.4          0.2"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_df = pd.DataFrame(X, columns=['sepal len', 'petal len',\n",
    "                                'sepal width', 'petal width'])\n",
    "X_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, the target array, `y`, can be optionally be cast as a Series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0\n",
       "1    0\n",
       "2    0\n",
       "3    0\n",
       "4    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_series = pd.Series(y)\n",
    "y_series.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "sfs1 = sfs1.fit(X_df, y_series)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the only difference of passing a pandas DataFrame as input is that the sfs1.subsets_ array will now contain a new column, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: {'feature_idx': (3,),\n",
       "  'cv_scores': array([0.96]),\n",
       "  'avg_score': 0.96,\n",
       "  'feature_names': ('petal width',)},\n",
       " 2: {'feature_idx': (2, 3),\n",
       "  'cv_scores': array([0.97333333]),\n",
       "  'avg_score': 0.9733333333333334,\n",
       "  'feature_names': ('sepal width', 'petal width')},\n",
       " 3: {'feature_idx': (1, 2, 3),\n",
       "  'cv_scores': array([0.97333333]),\n",
       "  'avg_score': 0.9733333333333334,\n",
       "  'feature_names': ('petal len', 'sepal width', 'petal width')}}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sfs1.subsets_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In mlxtend version >= 0.13 pandas DataFrames are supported as feature inputs to the `SequentianFeatureSelector` instead of NumPy arrays or other NumPy-like array types."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 13 - Specifying Fixed Feature Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often, it may be useful to specify a fixed set of features we want to use for a given model (e.g., determined by prior knowledge or domain knowledge). Since MLxtend v 0.18.0, it is now possible to specify such features via the `fixed_features` attribute. This will mean that these features are guaranteed to be included in the selected subsets.\n",
    "\n",
    "Note that this feature works for all options regarding forward and backward selection, and using floating selection or not.\n",
    "\n",
    "The example below illustrates how we can set the features 0 and 2 in the dataset as fixed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:39:57] Features: 3/4 -- score: 0.9733333333333333[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:39:57] Features: 4/4 -- score: 0.9733333333333333"
     ]
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.datasets import load_iris\n",
    "\n",
    "iris = load_iris()\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "knn = KNeighborsClassifier(n_neighbors=3)\n",
    "\n",
    "from mlxtend.feature_selection import SequentialFeatureSelector as SFS\n",
    "\n",
    "sfs1 = SFS(knn, \n",
    "           k_features=4, \n",
    "           forward=True, \n",
    "           floating=False, \n",
    "           verbose=2,\n",
    "           scoring='accuracy',\n",
    "           fixed_features=(0, 2),\n",
    "           cv=3)\n",
    "\n",
    "sfs1 = sfs1.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2: {'feature_idx': (0, 2),\n",
       "  'cv_scores': array([0.98, 0.92, 0.94]),\n",
       "  'avg_score': 0.9466666666666667,\n",
       "  'feature_names': ('0', '2')},\n",
       " 3: {'feature_idx': (0, 2, 3),\n",
       "  'cv_scores': array([0.98, 0.96, 0.98]),\n",
       "  'avg_score': 0.9733333333333333,\n",
       "  'feature_names': ('0', '2', '3')},\n",
       " 4: {'feature_idx': (0, 1, 2, 3),\n",
       "  'cv_scores': array([0.98, 0.96, 0.98]),\n",
       "  'avg_score': 0.9733333333333333,\n",
       "  'feature_names': ('0', '1', '2', '3')}}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sfs1.subsets_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the input dataset is a pandas DataFrame, we can also use the column names directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal len</th>\n",
       "      <th>petal len</th>\n",
       "      <th>sepal width</th>\n",
       "      <th>petal width</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal len  petal len  sepal width  petal width\n",
       "0        5.1        3.5          1.4          0.2\n",
       "1        4.9        3.0          1.4          0.2\n",
       "2        4.7        3.2          1.3          0.2\n",
       "3        4.6        3.1          1.5          0.2\n",
       "4        5.0        3.6          1.4          0.2"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_df = pd.DataFrame(X, columns=['sepal len', 'petal len',\n",
    "                                'sepal width', 'petal width'])\n",
    "X_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:39:57] Features: 3/4 -- score: 0.9466666666666667[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:39:57] Features: 4/4 -- score: 0.9733333333333333"
     ]
    }
   ],
   "source": [
    "sfs2 = SFS(knn, \n",
    "           k_features=4, \n",
    "           forward=True, \n",
    "           floating=False, \n",
    "           verbose=2,\n",
    "           scoring='accuracy',\n",
    "           fixed_features=('sepal len', 'petal len'),\n",
    "           cv=3)\n",
    "\n",
    "sfs2 = sfs2.fit(X_df, y_series)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2: {'feature_idx': (0, 1),\n",
       "  'cv_scores': array([0.72, 0.74, 0.78]),\n",
       "  'avg_score': 0.7466666666666667,\n",
       "  'feature_names': ('sepal len', 'petal len')},\n",
       " 3: {'feature_idx': (0, 1, 2),\n",
       "  'cv_scores': array([0.98, 0.92, 0.94]),\n",
       "  'avg_score': 0.9466666666666667,\n",
       "  'feature_names': ('sepal len', 'petal len', 'sepal width')},\n",
       " 4: {'feature_idx': (0, 1, 2, 3),\n",
       "  'cv_scores': array([0.98, 0.96, 0.98]),\n",
       "  'avg_score': 0.9733333333333333,\n",
       "  'feature_names': ('sepal len', 'petal len', 'sepal width', 'petal width')}}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sfs2.subsets_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 13 - Working with Feature Groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since mlxtend v0.21.0, it is possible to specify feature groups. Feature groups allow you to group certain features together, such that they are always selected as a group. This can be very useful in contexts similar to one-hot encoding -- if you want to treat the one-hot encoded feature as a single feature:\n",
    "\n",
    "![](SequentialFeatureSelector_files/feature_groups.jpeg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following example, we specify sepal length and sepal width as a feature group so that they are always selected together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal len</th>\n",
       "      <th>petal len</th>\n",
       "      <th>sepal wid</th>\n",
       "      <th>petal wid</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal len  petal len  sepal wid  petal wid\n",
       "0        5.1        3.5        1.4        0.2\n",
       "1        4.9        3.0        1.4        0.2\n",
       "2        4.7        3.2        1.3        0.2\n",
       "3        4.6        3.1        1.5        0.2\n",
       "4        5.0        3.6        1.4        0.2"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "import pandas as pd\n",
    "\n",
    "iris = load_iris()\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "\n",
    "X_df = pd.DataFrame(X, columns=['sepal len', 'petal len',\n",
    "                                'sepal wid', 'petal wid'])\n",
    "X_df.head()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from mlxtend.feature_selection import SequentialFeatureSelector as SFS\n",
    "\n",
    "knn = KNeighborsClassifier(n_neighbors=3)\n",
    "\n",
    "sfs1 = SFS(knn, \n",
    "           k_features=2, \n",
    "           scoring='accuracy',\n",
    "           feature_groups=(['sepal len', 'sepal wid'], ['petal len'], ['petal wid']),\n",
    "           cv=3)\n",
    "\n",
    "sfs1 = sfs1.fit(X_df, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sfs1 = SFS(knn, \n",
    "           k_features=2, \n",
    "           scoring='accuracy',\n",
    "           feature_groups=[[0, 2], [1], [3]],\n",
    "           cv=3)\n",
    "\n",
    "sfs1 = sfs1.fit(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 14 - Multiclass Metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Certain scoring metrics like ROC AUC are originally designed for binary classification. However, they can also be used for multiclass settings. It is best to consult [this scikit-learn metrics table](https://scikit-learn.org/stable/modules/model_evaluation.html#common-cases-predefined-values) for this.\n",
    "\n",
    "For example, we can use a ROC AUC One-Vs-Rest score via `‘\"roc_auc_ovr\"` as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import make_blobs\n",
    "X, y = make_blobs(n_samples=10, centers=4, n_features=5, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   5 out of   5 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:39:57] Features: 1/3 -- score: 1.0[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   4 out of   4 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:39:57] Features: 2/3 -- score: 1.0[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n",
      "[Parallel(n_jobs=1)]: Done   1 out of   1 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=1)]: Done   3 out of   3 | elapsed:    0.0s finished\n",
      "\n",
      "[2023-05-17 08:39:57] Features: 3/3 -- score: 1.0"
     ]
    }
   ],
   "source": [
    "from mlxtend.feature_selection import SequentialFeatureSelector as SFS\n",
    "\n",
    "sfs1 = SFS(knn, \n",
    "           k_features=3, \n",
    "           forward=True, \n",
    "           floating=False, \n",
    "           verbose=2,\n",
    "           scoring='roc_auc_ovr',\n",
    "           cv=0)\n",
    "\n",
    "sfs1 = sfs1.fit(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "## SequentialFeatureSelector\n",
      "\n",
      "*SequentialFeatureSelector(estimator, k_features=1, forward=True, floating=False, verbose=0, scoring=None, cv=5, n_jobs=1, pre_dispatch='2*n_jobs', clone_estimator=True, fixed_features=None, feature_groups=None)*\n",
      "\n",
      "Sequential Feature Selection for Classification and Regression.\n",
      "\n",
      "**Parameters**\n",
      "\n",
      "- `estimator` : scikit-learn classifier or regressor\n",
      "\n",
      "\n",
      "- `k_features` : int or tuple or str (default: 1)\n",
      "\n",
      "    Number of features to select,\n",
      "    where k_features < the full feature set.\n",
      "    New in 0.4.2: A tuple containing a min and max value can be provided,\n",
      "    and the SFS will consider return any feature combination between\n",
      "    min and max that scored highest in cross-validation. For example,\n",
      "    the tuple (1, 4) will return any combination from\n",
      "    1 up to 4 features instead of a fixed number of features k.\n",
      "    New in 0.8.0: A string argument \"best\" or \"parsimonious\".\n",
      "    If \"best\" is provided, the feature selector will return the\n",
      "    feature subset with the best cross-validation performance.\n",
      "    If \"parsimonious\" is provided as an argument, the smallest\n",
      "    feature subset that is within one standard error of the\n",
      "    cross-validation performance will be selected.\n",
      "\n",
      "\n",
      "- `forward` : bool (default: True)\n",
      "\n",
      "    Forward selection if True,\n",
      "    backward selection otherwise\n",
      "\n",
      "\n",
      "- `floating` : bool (default: False)\n",
      "\n",
      "    Adds a conditional exclusion/inclusion if True.\n",
      "\n",
      "\n",
      "- `verbose` : int (default: 0), level of verbosity to use in logging.\n",
      "\n",
      "    If 0, no output,\n",
      "    if 1 number of features in current set, if 2 detailed logging i\n",
      "    ncluding timestamp and cv scores at step.\n",
      "\n",
      "\n",
      "- `scoring` : str, callable, or None (default: None)\n",
      "\n",
      "    If None (default), uses 'accuracy' for sklearn classifiers\n",
      "    and 'r2' for sklearn regressors.\n",
      "    If str, uses a sklearn scoring metric string identifier, for example\n",
      "    {accuracy, f1, precision, recall, roc_auc} for classifiers,\n",
      "    {'mean_absolute_error', 'mean_squared_error'/'neg_mean_squared_error',\n",
      "    'median_absolute_error', 'r2'} for regressors.\n",
      "    If a callable object or function is provided, it has to be conform with\n",
      "    sklearn's signature ``scorer(estimator, X, y)``; see\n",
      "    https://scikit-learn.org/stable/modules/generated/sklearn.metrics.make_scorer.html\n",
      "    for more information.\n",
      "\n",
      "\n",
      "- `cv` : int (default: 5)\n",
      "\n",
      "    Integer or iterable yielding train, test splits. If cv is an integer\n",
      "    and `estimator` is a classifier (or y consists of integer class\n",
      "    labels) stratified k-fold. Otherwise regular k-fold cross-validation\n",
      "    is performed. No cross-validation if cv is None, False, or 0.\n",
      "\n",
      "\n",
      "- `n_jobs` : int (default: 1)\n",
      "\n",
      "    The number of CPUs to use for evaluating different feature subsets\n",
      "    in parallel. -1 means 'all CPUs'.\n",
      "\n",
      "\n",
      "- `pre_dispatch` : int, or string (default: '2*n_jobs')\n",
      "\n",
      "    Controls the number of jobs that get dispatched\n",
      "    during parallel execution if `n_jobs > 1` or `n_jobs=-1`.\n",
      "    Reducing this number can be useful to avoid an explosion of\n",
      "    memory consumption when more jobs get dispatched than CPUs can process.\n",
      "    This parameter can be:\n",
      "    None, in which case all the jobs are immediately created and spawned.\n",
      "    Use this for lightweight and fast-running jobs,\n",
      "    to avoid delays due to on-demand spawning of the jobs\n",
      "    An int, giving the exact number of total jobs that are spawned\n",
      "    A string, giving an expression as a function\n",
      "    of n_jobs, as in `2*n_jobs`\n",
      "\n",
      "\n",
      "- `clone_estimator` : bool (default: True)\n",
      "\n",
      "    Clones estimator if True; works with the original estimator instance\n",
      "    if False. Set to False if the estimator doesn't\n",
      "    implement scikit-learn's set_params and get_params methods.\n",
      "    In addition, it is required to set cv=0, and n_jobs=1.\n",
      "\n",
      "\n",
      "- `fixed_features` : tuple (default: None)\n",
      "\n",
      "    If not `None`, the feature indices provided as a tuple will be\n",
      "    regarded as fixed by the feature selector. For example, if\n",
      "    `fixed_features=(1, 3, 7)`, the 2nd, 4th, and 8th feature are\n",
      "    guaranteed to be present in the solution. Note that if\n",
      "    `fixed_features` is not `None`, make sure that the number of\n",
      "    features to be selected is greater than `len(fixed_features)`.\n",
      "    In other words, ensure that `k_features > len(fixed_features)`.\n",
      "    New in mlxtend v. 0.18.0.\n",
      "\n",
      "\n",
      "- `feature_groups` : list or None (default: None)\n",
      "\n",
      "    Optional argument for treating certain features as a group.\n",
      "    This means, the features within a group are always selected together,\n",
      "    never split.\n",
      "    For example, `feature_groups=[[1], [2], [3, 4, 5]]`\n",
      "    specifies 3 feature groups. In this case,\n",
      "    possible feature selection results with `k_features=2`\n",
      "    are `[[1], [2]`, `[[1], [3, 4, 5]]`, or `[[2], [3, 4, 5]]`.\n",
      "    Feature groups can be useful for\n",
      "    interpretability, for example, if features 3, 4, 5 are one-hot\n",
      "    encoded features.  (For  more details, please read the notes at the\n",
      "    bottom of this docstring).  New in mlxtend v. 0.21.0.\n",
      "\n",
      "**Attributes**\n",
      "\n",
      "- `k_feature_idx_` : array-like, shape = [n_predictions]\n",
      "\n",
      "    Feature Indices of the selected feature subsets.\n",
      "\n",
      "\n",
      "- `k_feature_names_` : array-like, shape = [n_predictions]\n",
      "\n",
      "    Feature names of the selected feature subsets. If pandas\n",
      "    DataFrames are used in the `fit` method, the feature\n",
      "    names correspond to the column names. Otherwise, the\n",
      "    feature names are string representation of the feature\n",
      "    array indices. New in v 0.13.0.\n",
      "\n",
      "\n",
      "- `k_score_` : float\n",
      "\n",
      "    Cross validation average score of the selected subset.\n",
      "\n",
      "\n",
      "- `subsets_` : dict\n",
      "\n",
      "    A dictionary of selected feature subsets during the\n",
      "    sequential selection, where the dictionary keys are\n",
      "    the lengths k of these feature subsets. If the parameter\n",
      "    `feature_groups` is not None, the value of key indicates\n",
      "    the number of groups that are selected together. The dictionary\n",
      "    values are dictionaries themselves with the following\n",
      "    keys: 'feature_idx' (tuple of indices of the feature subset)\n",
      "    'feature_names' (tuple of feature names of the feat. subset)\n",
      "    'cv_scores' (list individual cross-validation scores)\n",
      "    'avg_score' (average cross-validation score)\n",
      "    Note that if pandas\n",
      "    DataFrames are used in the `fit` method, the 'feature_names'\n",
      "    correspond to the column names. Otherwise, the\n",
      "    feature names are string representation of the feature\n",
      "    array indices. The 'feature_names' is new in v 0.13.0.\n",
      "\n",
      "**Notes**\n",
      "\n",
      "(1) If parameter `feature_groups` is not None, the\n",
      "    number of features is equal to the number of feature groups, i.e.\n",
      "    `len(feature_groups)`. For  example, if `feature_groups = [[0], [1], [2, 3],\n",
      "    [4]]`, then the `max_features` value cannot exceed 4.\n",
      "\n",
      "    (2) Although two or more individual features may be considered as one group\n",
      "    throughout the feature-selection process, it does not mean the individual\n",
      "    features of that group have the same impact on the outcome. For instance, in\n",
      "    linear regression, the coefficient of the feature 2 and 3 can be different\n",
      "    even if they are considered as one group in feature_groups.\n",
      "\n",
      "    (3) If both fixed_features and feature_groups are specified, ensure that each\n",
      "    feature group contains the fixed_features selection. E.g., for a 3-feature set\n",
      "    fixed_features=[0, 1] and feature_groups=[[0, 1], [2]] is valid;\n",
      "    fixed_features=[0, 1] and feature_groups=[[0], [1, 2]] is not valid.\n",
      "\n",
      "    (4) In case of KeyboardInterrupt, the dictionary subsets may not be completed.\n",
      "    If user is still interested in getting the best score, they can use method\n",
      "    `finalize_fit`.\n",
      "\n",
      "**Examples**\n",
      "\n",
      "For usage examples, please see\n",
      "    https://rasbt.github.io/mlxtend/user_guide/feature_selection/SequentialFeatureSelector/\n",
      "\n",
      "### Methods\n",
      "\n",
      "<hr>\n",
      "\n",
      "*finalize_fit()*\n",
      "\n",
      "None\n",
      "\n",
      "<hr>\n",
      "\n",
      "*fit(X, y, groups=None, **fit_params)*\n",
      "\n",
      "Perform feature selection and learn model from training data.\n",
      "\n",
      "**Parameters**\n",
      "\n",
      "- `X` : {array-like, sparse matrix}, shape = [n_samples, n_features]\n",
      "\n",
      "    Training vectors, where n_samples is the number of samples and\n",
      "    n_features is the number of features.\n",
      "    New in v 0.13.0: pandas DataFrames are now also accepted as\n",
      "    argument for X.\n",
      "\n",
      "- `y` : array-like, shape = [n_samples]\n",
      "\n",
      "    Target values.\n",
      "    New in v 0.13.0: pandas DataFrames are now also accepted as\n",
      "    argument for y.\n",
      "\n",
      "- `groups` : array-like, with shape (n_samples,), optional\n",
      "\n",
      "    Group labels for the samples used while splitting the dataset into\n",
      "    train/test set. Passed to the fit method of the cross-validator.\n",
      "\n",
      "- `fit_params` : various, optional\n",
      "\n",
      "    Additional parameters that are being passed to the estimator.\n",
      "    For example, `sample_weights=weights`.\n",
      "\n",
      "**Returns**\n",
      "\n",
      "- `self` : object\n",
      "\n",
      "\n",
      "<hr>\n",
      "\n",
      "*fit_transform(X, y, groups=None, **fit_params)*\n",
      "\n",
      "Fit to training data then reduce X to its most important features.\n",
      "\n",
      "**Parameters**\n",
      "\n",
      "- `X` : {array-like, sparse matrix}, shape = [n_samples, n_features]\n",
      "\n",
      "    Training vectors, where n_samples is the number of samples and\n",
      "    n_features is the number of features.\n",
      "    New in v 0.13.0: pandas DataFrames are now also accepted as\n",
      "    argument for X.\n",
      "\n",
      "- `y` : array-like, shape = [n_samples]\n",
      "\n",
      "    Target values.\n",
      "    New in v 0.13.0: a pandas Series are now also accepted as\n",
      "    argument for y.\n",
      "\n",
      "- `groups` : array-like, with shape (n_samples,), optional\n",
      "\n",
      "    Group labels for the samples used while splitting the dataset into\n",
      "    train/test set. Passed to the fit method of the cross-validator.\n",
      "\n",
      "- `fit_params` : various, optional\n",
      "\n",
      "    Additional parameters that are being passed to the estimator.\n",
      "    For example, `sample_weights=weights`.\n",
      "\n",
      "**Returns**\n",
      "\n",
      "Reduced feature subset of X, shape={n_samples, k_features}\n",
      "\n",
      "<hr>\n",
      "\n",
      "*generate_error_message_k_features(name)*\n",
      "\n",
      "None\n",
      "\n",
      "<hr>\n",
      "\n",
      "*get_metric_dict(confidence_interval=0.95)*\n",
      "\n",
      "Return metric dictionary\n",
      "\n",
      "**Parameters**\n",
      "\n",
      "- `confidence_interval` : float (default: 0.95)\n",
      "\n",
      "    A positive float between 0.0 and 1.0 to compute the confidence\n",
      "    interval bounds of the CV score averages.\n",
      "\n",
      "**Returns**\n",
      "\n",
      "Dictionary with items where each dictionary value is a list\n",
      "    with the number of iterations (number of feature subsets) as\n",
      "    its length. The dictionary keys corresponding to these lists\n",
      "    are as follows:\n",
      "    'feature_idx': tuple of the indices of the feature subset\n",
      "    'cv_scores': list with individual CV scores\n",
      "    'avg_score': of CV average scores\n",
      "    'std_dev': standard deviation of the CV score average\n",
      "    'std_err': standard error of the CV score average\n",
      "    'ci_bound': confidence interval bound of the CV score average\n",
      "\n",
      "<hr>\n",
      "\n",
      "*get_params(deep=True)*\n",
      "\n",
      "Get parameters for this estimator.\n",
      "\n",
      "**Parameters**\n",
      "\n",
      "- `deep` : bool, default=True\n",
      "\n",
      "    If True, will return the parameters for this estimator and\n",
      "    contained subobjects that are estimators.\n",
      "\n",
      "**Returns**\n",
      "\n",
      "- `params` : dict\n",
      "\n",
      "    Parameter names mapped to their values.\n",
      "\n",
      "<hr>\n",
      "\n",
      "*set_params(**params)*\n",
      "\n",
      "Set the parameters of this estimator.\n",
      "    Valid parameter keys can be listed with ``get_params()``.\n",
      "\n",
      "**Returns**\n",
      "\n",
      "self\n",
      "\n",
      "<hr>\n",
      "\n",
      "*transform(X)*\n",
      "\n",
      "Reduce X to its most important features.\n",
      "\n",
      "**Parameters**\n",
      "\n",
      "- `X` : {array-like, sparse matrix}, shape = [n_samples, n_features]\n",
      "\n",
      "    Training vectors, where n_samples is the number of samples and\n",
      "    n_features is the number of features.\n",
      "    New in v 0.13.0: pandas DataFrames are now also accepted as\n",
      "    argument for X.\n",
      "\n",
      "**Returns**\n",
      "\n",
      "Reduced feature subset of X, shape={n_samples, k_features}\n",
      "\n",
      "### Properties\n",
      "\n",
      "<hr>\n",
      "\n",
      "*named_estimators*\n",
      "\n",
      "**Returns**\n",
      "\n",
      "List of named estimator tuples, like [('svc', SVC(...))]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open('../../api_modules/mlxtend.feature_selection/SequentialFeatureSelector.md', 'r') as f:\n",
    "    s = f.read()\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.16"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}