examples/notebooks/spark/pyspark_random_forest_explain.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import findspark \n",
    "findspark.init()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql import SparkSession\n",
    "spark = SparkSession.builder.appName(\"random_forest_explain\").config(\"spark.sql.execution.arrow.enabled\", \"true\").enableHiveSupport().getOrCreate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "from typing import List\n",
    "from itertools import chain\n",
    "from pyspark.ml import Model\n",
    "from pyspark.ml import Pipeline, PipelineModel\n",
    "from pyspark.sql import SparkSession, DataFrame\n",
    "from pyspark.ml.regression import RandomForestRegressor\n",
    "from pyspark.ml.classification import RandomForestClassifier\n",
    "from pyspark.ml.feature import StringIndexer, VectorAssembler, SQLTransformer, OneHotEncoder\n",
    "\n",
    "from transparency.spark.ohe.decoder import OneHotDecoder\n",
    "from transparency.spark.prediction.explainer.tree import EnsembleTreeExplainTransformer\n",
    "\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ensemble_pipeline_stages(categorical_columns, continuous_columns, label_column, ensemble_type,\n",
    "                                 classification=False\n",
    "                                 ) -> List:\n",
    "    encoders = []\n",
    "    for c in categorical_columns:\n",
    "        indexer = StringIndexer(inputCol=c, outputCol=f\"{c}_IDX\")\n",
    "        encoders.append(indexer)\n",
    "        encoder = OneHotEncoder(inputCol=indexer.getOutputCol(), outputCol=f\"{c}_OHE\", dropLast=False)\n",
    "        encoders.append(encoder)\n",
    "\n",
    "    features_column = f\"features_{label_column}\"\n",
    "    prediction_column = f\"prediction_{label_column}\"\n",
    "\n",
    "    assembler = VectorAssembler(inputCols=[f\"{c}_OHE\" for c in categorical_columns] + continuous_columns,\n",
    "                                outputCol=features_column)\n",
    "\n",
    "  \n",
    "    if classification:\n",
    "        _model = RandomForestClassifier(labelCol=label_column, featuresCol=features_column, predictionCol=prediction_column)\n",
    "    else:  \n",
    "        _model = RandomForestRegressor(labelCol=label_column, featuresCol=features_column, predictionCol=prediction_column)\n",
    "    \n",
    "    stages: List = encoders + [assembler, _model]\n",
    "\n",
    "    return stages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_feature_importance(spark_session: SparkSession, model: Model, prediction_df: DataFrame,\n",
    "                           feature_column: str, ) -> DataFrame:\n",
    "    ml_attributes = prediction_df.schema[feature_column].metadata[\"ml_attr\"][\"attrs\"].values()\n",
    "    attrs = sorted((attr[\"idx\"], attr[\"name\"]) for attr in (chain(*ml_attributes)))\n",
    "    feature_importance = [\n",
    "        (idx, re.sub('[^0-9a-zA-Z]+', '_', name), name, float(model.featureImportances[idx]))\n",
    "        for\n",
    "        idx, name\n",
    "        in attrs]\n",
    "    feature_importance.sort(key=lambda x: x[3], reverse=True)\n",
    "    feature_importance_df: DataFrame = spark_session.createDataFrame(feature_importance).toDF(\"Feature_Index\",\n",
    "                                                                                              \"Feature\",\n",
    "                                                                                              \"Original_Feature\",\n",
    "                                                                                              \"Importance\")\n",
    "\n",
    "    return feature_importance_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ensemble_explain_stages(predictions_view: str, features_importance_view: str, label_column: str,\n",
    "                                rf_model_path: str, ensemble_type: str, classification=False) -> List:\n",
    "    stages = [\n",
    "        OneHotDecoder(oheSuffix=\"_OHE\", idxSuffix=\"_IDX\", unknownSuffix=\"Unknown\"),\n",
    "        SQLTransformer(statement=f\"CREATE OR REPLACE TEMPORARY VIEW {predictions_view} AS SELECT * from __THIS__\"),\n",
    "        EnsembleTreeExplainTransformer(predictionView=predictions_view, featureImportanceView=features_importance_view,\n",
    "                                       modelPath=rf_model_path, label=label_column,\n",
    "                                       dropPathColumn=True, isClassification=classification, ensembleType=ensemble_type)\n",
    "    ]\n",
    "    return stages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random Forest Regression \n",
    "- The example below is using **boston dataset** for preciting the **median home prices** for occupied homes.\n",
    "- The example is stricitly used for **demonstrating** the uagae of `EnsembleTreeExplainTransformer`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "boston_csv = '/work/tests/data/regression/dataset_boston.csv'\n",
    "boston_df: DataFrame = spark.read.option(\"header\", True).option(\"inferSchema\", True).csv(boston_csv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_column = 'medv'\n",
    "features_column = f\"features_{label_column}\"\n",
    "prediction_column = f\"prediction_{label_column}\"\n",
    "\n",
    "contrib_column = f\"prediction_{label_column}_contrib\"\n",
    "contrib_column_sum = f\"{contrib_column}_sum\"\n",
    "contrib_column_intercept = f\"{contrib_column}_intercept\"\n",
    "\n",
    "features_importance_view = f\"features_importance_{label_column}_view\"\n",
    "predictions_view = f\"predictions_{label_column}_view\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "categorical_columns=[]\n",
    "continuous_columns = [x for x in boston_df.columns if x not in ['id', label_column]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "stages = get_ensemble_pipeline_stages([], continuous_columns + categorical_columns, label_column, ensemble_type=\"rf\",classification=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import uuid\n",
    "pipeline = Pipeline(stages=stages)\n",
    "pipeline_model: PipelineModel = pipeline.fit(boston_df)\n",
    "rf_model = pipeline_model.stages[-1]\n",
    "string_id = uuid.uuid4()\n",
    "rf_model_path: str = f\"/tmp/{string_id}\"\n",
    "rf_model.write().save(rf_model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "prediction_df = pipeline_model.transform(boston_df)\n",
    "prediction_df.createOrReplaceTempView(predictions_view)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "features_importance_df = get_feature_importance(spark, rf_model, prediction_df, features_column)\n",
    "features_importance_df.createOrReplaceTempView(features_importance_view)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "explain_stages = get_ensemble_explain_stages(predictions_view, features_importance_view, label_column, rf_model_path,ensemble_type=\"rf\",classification=False)\n",
    "explain_pipeline = Pipeline(stages=explain_stages)\n",
    "explain_df = explain_pipeline.fit(prediction_df).transform(prediction_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_index_meta = features_importance_df.select(\"Feature_Index\", \"Feature\").orderBy(\"Feature_Index\").rdd.collectAsMap()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "expressions = []\n",
    "for key,value in feature_index_meta.items():\n",
    "    expressions.append(f\"AVG({contrib_column}[{key}]) as {value}\")\n",
    "\n",
    "contributions = explain_df.selectExpr(expressions).collect()[0].asDict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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>Contributions</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>crim</th>\n",
       "      <td>-0.662769</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>zn</th>\n",
       "      <td>-0.002142</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>indus</th>\n",
       "      <td>-1.233678</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>chas</th>\n",
       "      <td>0.027064</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>nox</th>\n",
       "      <td>-0.596287</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       Contributions\n",
       "crim       -0.662769\n",
       "zn         -0.002142\n",
       "indus      -1.233678\n",
       "chas        0.027064\n",
       "nox        -0.596287"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_contrib_df = pd.DataFrame.from_dict(contributions,orient='index',columns=['Contributions'])\n",
    "plot_contrib_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "final_plot_contrib_df = plot_contrib_df.iloc[plot_contrib_df['Contributions'].abs().argsort()]\n",
    "final_plot_contrib_df.plot(kind='barh', figsize=(9, 7))\n",
    "plt.title('Feature Contributions')\n",
    "plt.axvline(x=0, color='.5')\n",
    "plt.subplots_adjust(left=.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random Forest Classification \n",
    "- The example below is using **prima india diabetes dataset** for preciting the **diabetes outcome** for patient.\n",
    "- The example is stricitly used for **demonstrating** the uagae of `GLMExplainTransformer`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "prima_indian_diabetes_csv = '/work/tests/data/classification/dataset_prima_indian_diabetes.csv'\n",
    "prima_indian_diabetes_df = spark.read.option(\"header\", True).option(\"inferSchema\", True).csv(\n",
    "    prima_indian_diabetes_csv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_column = 'outcome'\n",
    "features_column = f\"features_{label_column}\"\n",
    "prediction_column = f\"prediction_{label_column}\"\n",
    "\n",
    "contrib_column = f\"prediction_{label_column}_contrib\"\n",
    "contrib_column_sum = f\"{contrib_column}_sum\"\n",
    "contrib_column_intercept = f\"{contrib_column}_intercept\"\n",
    "\n",
    "features_importance_view = f\"features_importance_{label_column}_view\"\n",
    "predictions_view = f\"predictions_{label_column}_view\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "categorical_columns=[]\n",
    "continuous_columns = [x for x in prima_indian_diabetes_df.columns if x not in ['id', label_column]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "stages = get_ensemble_pipeline_stages([], continuous_columns + categorical_columns, label_column, ensemble_type=\"rf\",classification=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "import uuid\n",
    "pipeline = Pipeline(stages=stages)\n",
    "pipeline_model: PipelineModel = pipeline.fit(prima_indian_diabetes_df)\n",
    "rf_model = pipeline_model.stages[-1]\n",
    "string_id = uuid.uuid4()\n",
    "rf_model_path: str = f\"/tmp/{string_id}\"\n",
    "rf_model.write().save(rf_model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "prediction_df = pipeline_model.transform(prima_indian_diabetes_df)\n",
    "prediction_df.createOrReplaceTempView(predictions_view)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "features_importance_df = get_feature_importance(spark, rf_model, prediction_df, features_column)\n",
    "features_importance_df.createOrReplaceTempView(features_importance_view)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "explain_stages = get_ensemble_explain_stages(predictions_view, features_importance_view, label_column, rf_model_path,ensemble_type=\"rf\",classification=True)\n",
    "explain_pipeline = Pipeline(stages=explain_stages)\n",
    "explain_df = explain_pipeline.fit(prediction_df).transform(prediction_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_index_meta = features_importance_df.select(\"Feature_Index\", \"Feature\").orderBy(\"Feature_Index\").rdd.collectAsMap()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "expressions = []\n",
    "for key,value in feature_index_meta.items():\n",
    "    expressions.append(f\"AVG({contrib_column}[{key}]) as {value}\")\n",
    "\n",
    "contributions = explain_df.selectExpr(expressions).collect()[0].asDict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "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>Contributions</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>pregnancies</th>\n",
       "      <td>0.018229</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>glucose</th>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>blood_pressure</th>\n",
       "      <td>-0.049479</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>skin_thickness</th>\n",
       "      <td>0.023438</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>insulin</th>\n",
       "      <td>-0.032552</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                Contributions\n",
       "pregnancies          0.018229\n",
       "glucose              0.000000\n",
       "blood_pressure      -0.049479\n",
       "skin_thickness       0.023438\n",
       "insulin             -0.032552"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_contrib_df = pd.DataFrame.from_dict(contributions,orient='index',columns=['Contributions'])\n",
    "plot_contrib_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "final_plot_contrib_df = plot_contrib_df.iloc[plot_contrib_df['Contributions'].abs().argsort()]\n",
    "final_plot_contrib_df.plot(kind='barh', figsize=(9, 7))\n",
    "plt.title('Feature Contributions')\n",
    "plt.axvline(x=0, color='.5')\n",
    "plt.subplots_adjust(left=.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}