interpretable_features/Lab - Interpretable Features.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "45017587",
   "metadata": {},
   "source": [
    "## Lab - Using Interpretable Features for Model Debugging\n",
    "\n",
    "In our lecture on interpretable features, you learned about the importance of using interpretable features for interpretable models. As we talked about, one of the benefits of interpretable machien learning is it makes it easier to identify the source of a problem with a deployed model.\n",
    "\n",
    "In this lab, we'll be working with a modified version of the Ames Housing Dataset (CITE). In this dataset, each row represents a single house in Ames Iowa, and our model is traiend to predict the final sale price of the house. \n",
    "\n",
    "In our hypothetical scenario, a real estate agent has deployed a model to help they set the initial sale price houses newly on the market. However, despite decent train and test scores during model training, the agent has found that the house predictions are terrible in the real world. They suspect something went wrong with the data, and want to use methods from *XAI* (explainable AI) to identify the problem.\n",
    "\n",
    "Your task will be to try to find the issue with the data. You will try transforming the data in different ways to train multiple models with different levels of *feature interpretability*. There are **two mistakes** intentionally added to the dataset. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "810f2158",
   "metadata": {},
   "source": [
    "### Data Setup\n",
    "\n",
    "Run the cells below to install libraries, load in the (flawed) dataset, and take an initial look at the data. **After running the first (pip install) cell, make sure to restart your kernel by using Kernel -> Restart in the toolbar, the continue running from the second cell.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2783eff8",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "%pip install lightgbm\n",
    "%pip install featuretools\n",
    "%pip install pyreal==0.3.1.1\n",
    "%pip install matplotlib==3.5.3\n",
    "%pip install numpy==1.23.5\n",
    "%pip install shap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "74f7e9e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`sparse` was renamed to `sparse_output` in version 1.2 and will be removed in 1.4. `sparse_output` is ignored unless you leave `sparse` to its default value.\n"
     ]
    },
    {
     "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>LotFrontage</th>\n",
       "      <th>LotArea</th>\n",
       "      <th>Street</th>\n",
       "      <th>LotShape</th>\n",
       "      <th>Utilities</th>\n",
       "      <th>LandSlope</th>\n",
       "      <th>OverallQual</th>\n",
       "      <th>OverallCond</th>\n",
       "      <th>YearBuilt</th>\n",
       "      <th>YearRemodAdd</th>\n",
       "      <th>...</th>\n",
       "      <th>Heating</th>\n",
       "      <th>CentralAir</th>\n",
       "      <th>Electrical</th>\n",
       "      <th>GarageType</th>\n",
       "      <th>GarageFinish</th>\n",
       "      <th>Fence</th>\n",
       "      <th>MiscFeature</th>\n",
       "      <th>MoSold</th>\n",
       "      <th>SaleType</th>\n",
       "      <th>SaleCondition</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>107.0</td>\n",
       "      <td>13891</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "      <td>2006</td>\n",
       "      <td>2006</td>\n",
       "      <td>...</td>\n",
       "      <td>GasA</td>\n",
       "      <td>Y</td>\n",
       "      <td>SBrkr</td>\n",
       "      <td>Attchd</td>\n",
       "      <td>Fin</td>\n",
       "      <td>No</td>\n",
       "      <td>No</td>\n",
       "      <td>Sep</td>\n",
       "      <td>New</td>\n",
       "      <td>Partial</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50.0</td>\n",
       "      <td>6060</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>7</td>\n",
       "      <td>5</td>\n",
       "      <td>1939</td>\n",
       "      <td>1950</td>\n",
       "      <td>...</td>\n",
       "      <td>GasA</td>\n",
       "      <td>Y</td>\n",
       "      <td>SBrkr</td>\n",
       "      <td>Detchd</td>\n",
       "      <td>Unf</td>\n",
       "      <td>MnPrv</td>\n",
       "      <td>No</td>\n",
       "      <td>Jun</td>\n",
       "      <td>WD</td>\n",
       "      <td>Normal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>60.0</td>\n",
       "      <td>6000</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>1941</td>\n",
       "      <td>1950</td>\n",
       "      <td>...</td>\n",
       "      <td>GasA</td>\n",
       "      <td>Y</td>\n",
       "      <td>SBrkr</td>\n",
       "      <td>Detchd</td>\n",
       "      <td>Unf</td>\n",
       "      <td>No</td>\n",
       "      <td>No</td>\n",
       "      <td>Mar</td>\n",
       "      <td>WD</td>\n",
       "      <td>Normal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>70.0</td>\n",
       "      <td>7728</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "      <td>1962</td>\n",
       "      <td>1962</td>\n",
       "      <td>...</td>\n",
       "      <td>GasA</td>\n",
       "      <td>Y</td>\n",
       "      <td>SBrkr</td>\n",
       "      <td>Attchd</td>\n",
       "      <td>Unf</td>\n",
       "      <td>GdWo</td>\n",
       "      <td>No</td>\n",
       "      <td>May</td>\n",
       "      <td>WD</td>\n",
       "      <td>Normal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>80.0</td>\n",
       "      <td>10480</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "      <td>1976</td>\n",
       "      <td>1976</td>\n",
       "      <td>...</td>\n",
       "      <td>GasA</td>\n",
       "      <td>Y</td>\n",
       "      <td>SBrkr</td>\n",
       "      <td>Attchd</td>\n",
       "      <td>RFn</td>\n",
       "      <td>No</td>\n",
       "      <td>No</td>\n",
       "      <td>Sep</td>\n",
       "      <td>WD</td>\n",
       "      <td>Normal</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 80 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   LotFrontage  LotArea  Street  LotShape  Utilities  LandSlope  OverallQual  \\\n",
       "0        107.0    13891       2         4          4          3            1   \n",
       "1         50.0     6060       2         4          4          3            7   \n",
       "2         60.0     6000       2         4          4          3            5   \n",
       "3         70.0     7728       2         4          4          3            6   \n",
       "4         80.0    10480       2         4          4          3            4   \n",
       "\n",
       "   OverallCond  YearBuilt  YearRemodAdd  ...  Heating  CentralAir  Electrical  \\\n",
       "0            5       2006          2006  ...     GasA           Y       SBrkr   \n",
       "1            5       1939          1950  ...     GasA           Y       SBrkr   \n",
       "2            6       1941          1950  ...     GasA           Y       SBrkr   \n",
       "3            6       1962          1962  ...     GasA           Y       SBrkr   \n",
       "4            6       1976          1976  ...     GasA           Y       SBrkr   \n",
       "\n",
       "   GarageType  GarageFinish  Fence  MiscFeature  MoSold  SaleType  \\\n",
       "0      Attchd           Fin     No           No     Sep       New   \n",
       "1      Detchd           Unf  MnPrv           No     Jun        WD   \n",
       "2      Detchd           Unf     No           No     Mar        WD   \n",
       "3      Attchd           Unf   GdWo           No     May        WD   \n",
       "4      Attchd           RFn     No           No     Sep        WD   \n",
       "\n",
       "   SaleCondition  \n",
       "0        Partial  \n",
       "1         Normal  \n",
       "2         Normal  \n",
       "3         Normal  \n",
       "4         Normal  \n",
       "\n",
       "[5 rows x 80 columns]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import lightgbm\n",
    "from pyreal.transformers import OneHotEncoder, DataFrameWrapper, fit_transformers, run_transformers\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def one_hot_encode(X_train, X_test):\n",
    "    categorical_features = X_train.select_dtypes(exclude=[np.number]).columns\n",
    "    ohe = OneHotEncoder(columns=categorical_features)\n",
    "    \n",
    "    ohe.fit(pd.concat((X_train, X_test), axis=0))\n",
    "\n",
    "    return ohe.transform(X_train), ohe.transform(X_test)\n",
    "\n",
    "def fit_model(X_train, y_train):\n",
    "    return lightgbm.LGBMRegressor().fit(X_train, y_train)\n",
    "\n",
    "train_data = pd.read_csv(\"train_data.csv\")\n",
    "test_data = pd.read_csv(\"test_data.csv\")\n",
    "\n",
    "y_train = train_data.SalePrice\n",
    "X_train = train_data.drop(\"SalePrice\", axis=1)\n",
    "\n",
    "y_test = test_data.SalePrice\n",
    "X_test = test_data.drop(\"SalePrice\", axis=1)\n",
    "\n",
    "X_train_model, X_test_model = one_hot_encode(X_train, X_test)\n",
    "feature_df = pd.read_csv(\"feature_descriptions.csv\") # includes information about features\n",
    "\n",
    "X_train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57c51ffe",
   "metadata": {},
   "source": [
    "### Generating Explanations\n",
    "\n",
    "To generate explanations throughout this lab, we will be using the popular explanation library [shap](https://shap.readthedocs.io/en/latest/). SHAP is a *model agnostic* explanation tool, meaning it can be used to explain any ML model, regardless of architecture --- however, as we will see, its explanations are less than useful when using uninterpretable features.\n",
    "\n",
    "The shap library offers many different (plotting options)[https://shap.readthedocs.io/en/latest/api_examples.html#plots], you can try multiple out to see what works best for your task. Some plots provide *local explantions*, which explain the logic behind a single prediction. For this lab, you will be working with *global explanations*, which explain the model's logic overall. \n",
    "\n",
    "As a start, we recommend you try the **beeswarm** plot. This chart lists the feature the model considers most important on top, with reducing importance going down the y-axis. Each point represents a line in the dataset, with the color representing the value of the feature. The SHAP impact value, on the x-axis represents how much that feature value contributed to the model prediction. A higher value along the x-axis means that feature was highly positively correlated with the model prediction, while a lower value means it was negatively correlated. A SHAP value of zero means that feature value had no effect on the model prediction.\n",
    "\n",
    "For example, in the sample visualization below, higher median income and lower populations in house blocks tends to result in higher house prices (which makes sense!) \n",
    "\n",
    "![example explanation](example_explanation.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cddbedde",
   "metadata": {},
   "source": [
    "Run the cell below for two helper functions that will get you started on generating explanations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "d2743763",
   "metadata": {},
   "outputs": [],
   "source": [
    "import shap\n",
    "\n",
    "def explain(model, X_train):\n",
    "    \"\"\"\n",
    "    Explain a model with a beeswarm plot. \n",
    "    \n",
    "    model: a machine learning model\n",
    "    X_train: a dataset of valid inputs to model\n",
    "    \"\"\"\n",
    "    explainer = shap.explainers.Tree(model, X_train)\n",
    "    shap_values = explainer(X_train)\n",
    "\n",
    "    shap.plots.beeswarm(shap_values, max_display=10)\n",
    "\n",
    "def explain_feature(model, X_train, feature_name):\n",
    "    \"\"\"\n",
    "    Generate an explanation for the impact of a specific \n",
    "    feature on model predictions.\n",
    "    \n",
    "    model: a machine learning model\n",
    "    X_train: a dataset of valid inputs to model\n",
    "    feature_name: string, the name of a feature to investigate\n",
    "    \"\"\"\n",
    "    explainer = shap.explainers.Tree(model, X_train)\n",
    "    shap_values = explainer(X_train)\n",
    "\n",
    "    shap.plots.scatter(shap_values[:, feature_name])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8eb9a026",
   "metadata": {},
   "source": [
    "### Feature Transforms 1: PCA\n",
    "\n",
    "We will begin by running a [PCA (Principle Component Analysis)](https://builtin.com/data-science/step-step-explanation-principal-component-analysis) on the data. Run the cell below to standardize and PCA transform the data, and train a light GBM model. Note the performance (given as an [R^2](https://www.geeksforgeeks.org/ml-r-squared-in-regression-analysis/) score)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "ff34077e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of PCA components used: 155\n",
      "R^2 Score (PCA): 0.864\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "scaler = DataFrameWrapper(StandardScaler())\n",
    "\n",
    "X_train_std = scaler.fit_transform(X_train_model)\n",
    "X_test_std = scaler.transform(X_test_model)\n",
    "\n",
    "pca = PCA(n_components=0.95)\n",
    "pca.fit(X_train_std)\n",
    "\n",
    "X_train_pca = pd.DataFrame(pca.transform(X_train_std), columns=pca.get_feature_names_out())\n",
    "X_test_pca = pd.DataFrame(pca.transform(X_test_std), columns=pca.get_feature_names_out())\n",
    "\n",
    "model_pca = fit_model(X_train_pca, y_train)\n",
    "\n",
    "print(\"Number of PCA components used: %i\" % pca.n_components_)\n",
    "print(\"R^2 Score (PCA): %.3f\" % model_pca.score(X_test_pca, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dbf9354",
   "metadata": {},
   "source": [
    "In the cell below, use the explanation helper functions (or others from the shap library/other explanation libraries you may be interested in trying) to generate some explanations of the model's prediction. Think about what additional steps you may need to take to identify the source of poor performance. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "7f3c34f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate an explanation of the PCA model, and see if you can identify the data flaw\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba54738d",
   "metadata": {},
   "source": [
    "### Feature Transforms 2: Automatic Feature Engineering\n",
    "\n",
    "Next, we will try a different set of transformations using an automatic feature engineering tool - [Featuretools](https://www.featuretools.com/). This is a powerful library that makes it possible to dry hundreds of feature engineering options with just a few lines of code. There are many situations were this is a very useful process - but as we'll see below, automatic feature engineering without care can lead to less interpretable features.\n",
    "\n",
    "Run the cell below to generate a significantly larger dataset of engineered features. This process may be slow - you can load in the pretrained results of the engineering process by setting `load_pretrained = True`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "28861e24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting deep feature synthesis on training data\n",
      "Starting feature engineering on testing data\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`sparse` was renamed to `sparse_output` in version 1.2 and will be removed in 1.4. `sparse_output` is ignored unless you leave `sparse` to its default value.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R2 Score (Featuretools): 0.8043014861316414\n"
     ]
    }
   ],
   "source": [
    "import featuretools as ft\n",
    "\n",
    "load_pretrained = False\n",
    "\n",
    "def make_entity_set(X):\n",
    "    es = ft.EntitySet(id=\"houses\")\n",
    "    \n",
    "    X_with_ind = X.copy()\n",
    "    X_with_ind['index'] = X_with_ind.index\n",
    "    \n",
    "    es = es.add_dataframe(\n",
    "      dataframe_name=\"houses\",\n",
    "      dataframe=X_with_ind,\n",
    "      index=\"index\",\n",
    "    )\n",
    "    \n",
    "    return es\n",
    "\n",
    "def feature_engineer(es, num_to_engineer=15, primitives=None):\n",
    "    # To avoid large computation times, we \n",
    "    ignore_features = list(feature_df[\"name\"][num_to_engineer:])\n",
    "    \n",
    "    if primitives is None:\n",
    "        # To avoid large computation times, we'll just work with a truncated set of options\n",
    "        primitives = ['multiply_numeric', \"greater_than\", \"divide_by_feature\", \"cosine\", \"tangent\"]\n",
    "  \n",
    "    feature_matrix, feature_defs = ft.dfs(\n",
    "        entityset=es,\n",
    "        target_dataframe_name=\"houses\",\n",
    "        trans_primitives=primitives,\n",
    "        ignore_columns={\"houses\": ignore_features},\n",
    "        max_depth=1,\n",
    "        max_features=1000\n",
    "    )\n",
    "    \n",
    "    return feature_matrix, feature_defs\n",
    "\n",
    "if load_pretrained:\n",
    "    X_train_ft = pd.read_csv(\"X_train_ft.csv\")\n",
    "    X_test_ft = pd.read_csv(\"X_test_ft.csv\")\n",
    "\n",
    "else:\n",
    "    print(\"Starting deep feature synthesis on training data\")\n",
    "    X_train_ft, feature_defs = feature_engineer(make_entity_set(X_train))\n",
    "\n",
    "    print(\"Starting feature engineering on testing data\")\n",
    "    X_test_ft = ft.calculate_feature_matrix(feature_defs, make_entity_set(X_test))\n",
    "\n",
    "X_train_ft_model, X_test_ft_model = one_hot_encode(X_train_ft, X_test_ft)\n",
    "\n",
    "model_ft = fit_model(X_train_ft_model, y_train)\n",
    "print(\"R2 Score (Featuretools):\", model_ft.score(X_test_ft_model, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bb54764",
   "metadata": {},
   "source": [
    "Once again, try generating explanations on the generated data, and see if you can guess at the flaw in the data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "2d552584",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate explanations here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "388dd176",
   "metadata": {},
   "source": [
    "### Basic Feature Transformations\n",
    "\n",
    "In many datasets, complex feature engineering does not offer a lot (or any!) boost in model performance, while lowering the interpretability of features. In this dataset, we happened to be given data already turned into useful features. Again, we will train a model on a set of features. Then, try generating some explanations and see if you can guess at the data flaw."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "e49e3f30",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R2 Score (Original): 0.9238520966108774\n"
     ]
    }
   ],
   "source": [
    "model_orig = fit_model(X_train_std, y_train)\n",
    "print(\"R2 Score (Original):\", model_orig.score(X_test_std, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "dce68d43",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate explanations here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6a92dbe",
   "metadata": {},
   "source": [
    "### Boosting Feature Interpretability\n",
    "\n",
    "You may have already guessed at one or both flaws in the data based on the explanations generated above, but we can make explanations that are even more immedietely readable by using a library that factors in feature interpretability like [Pyreal](https://dtail.gitbook.io/pyreal/). The example below shows the setup for a Global Feature Importance explanation, which provides one overall importance value per feature to show you which features are most used by the model generally. \n",
    "\n",
    "The explanation you generate in the cell below should help you identify one of the data flaws."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "2b689910",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`sparse` was renamed to `sparse_output` in version 1.2 and will be removed in 1.4. `sparse_output` is ignored unless you leave `sparse` to its default value.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pyreal.explainers import GlobalFeatureImportance, LocalFeatureContribution\n",
    "from pyreal.utils.visualize import plot_top_contributors, swarm_plot\n",
    "\n",
    "feature_descriptions = dict(zip(feature_df.name, feature_df.description))\n",
    "\n",
    "categorical_features = X_train.select_dtypes(exclude=[np.number]).columns\n",
    "ohe = OneHotEncoder(columns=categorical_features)\n",
    "scaler = DataFrameWrapper(StandardScaler())\n",
    "\n",
    "ohe.fit(pd.concat((X_train, X_test), axis=0))\n",
    "scaler.fit(ohe.transform(X_train))\n",
    "\n",
    "global_explainer = GlobalFeatureImportance(model_orig, x_train_orig=X_train, \n",
    "                                           e_algorithm=\"shap\", transformers=[ohe, scaler], \n",
    "                                           feature_descriptions=feature_descriptions, \n",
    "                                           fit_on_init=True)\n",
    "\n",
    "explanation = global_explainer.produce()\n",
    "plot_top_contributors(explanation, n=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c480052",
   "metadata": {},
   "source": [
    "Now, use the example above as well as additional documentation [here](https://dtail.gitbook.io/pyreal/getting-started/quickstart) to generate a Local Feature Contribution explanation, which will give you further information about the exact positive and negative contributions of each feature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "c5aae67c",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (1082507576.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[33], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m    local_explainer = # your code here #\u001b[0m\n\u001b[0m                      ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "local_explainer = # your code here #\n",
    "\n",
    "local_explanation, x_interpret = # your code here #"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8685160e",
   "metadata": {},
   "source": [
    "You can now look at multiple individual explanations individually using `plot_top_contributors`, or you may find it more useful to generate a swarm plot like the ones above using Pyreals [swarm_plot](https://sibyl-ml.dev/pyreal/api_reference/api/pyreal.utils.visualize.swarm_plot.html#pyreal.utils.visualize.swarm_plot) function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34eadde6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here #"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97ed2405",
   "metadata": {},
   "source": [
    "### Results\n",
    "\n",
    "As you may have determined from the explanations above, the data has two flaws.\n",
    "\n",
    "<details>\n",
    "<summary><font color='blue'> Click to reveal solution </font></summary>The first is an example of **data leakage**, by including a feature for the bid price on houses sold in the past. We won't have access to the information for new houses on the market, so a model that relies heavily on this information will not be useful for setting the original house price.\n",
    "\n",
    "The second was a mistake in the engineering of features, resulting in higher quality of housing materials leading to lower model predictions. If this mistake does not exist in new data coming in, we can expect model performance to decrease. \n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc80977f",
   "metadata": {},
   "source": [
    "### Bonus activity\n",
    "\n",
    "If you'd like to get more experience with generating interpretable features, try finding a dataset on a topic you know a lot about. Generate features based on information you know is important, and then compare the explanations and performance to features generated automatically using a tool like the ones above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd2ba7ff",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}