notebooks/classifier-boundary-animations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Animations showing feature space and classification boundaries\n",
    "\n",
    "While dtreeviz is dedicated primarily to showing decision trees, we have also provided a way to show the decision boundaries for one- and two- variable classifiers. The `decision_boundaries()` function will work with any model that answers method `predict_proba()` and with Keras, for which we provided a special adapter (since that method is deprecated).\n",
    "\n",
    "Using a silly little `pltvid` library I built, we can do some simple animations.  I think it doesn't work on Windows because I directly relied on `/tmp` dir. Sorry.\n",
    "\n",
    "## Requirements\n",
    "\n",
    "**This notebook requires poppler lib due to pltvid lib**\n",
    "\n",
    "On mac:\n",
    "```\n",
    "brew install poppler\n",
    "```\n",
    "\n",
    "Also needs my helper lib:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "! pip install --quiet -U pltvid  # simple animation support by parrt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from sklearn.linear_model import LinearRegression, Ridge, Lasso, LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor\n",
    "\n",
    "from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor\n",
    "from sklearn.datasets import load_boston, load_iris, load_wine, load_digits, \\\n",
    "                             load_breast_cancer, load_diabetes\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix, precision_score, recall_score\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.collections import PatchCollection\n",
    "%config InlineBackend.figure_format = 'svg'  # Looks MUCH better than retina\n",
    "# %config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "from rfpimp import *   # pip install rfpimp\n",
    "\n",
    "from sklearn import tree\n",
    "\n",
    "import dtreeviz\n",
    "from dtreeviz import decision_boundaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wine data set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "wine = load_wine()\n",
    "X = wine.data\n",
    "X = X[:,[12,6]]\n",
    "y = wine.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(min_samples_leaf=20, n_estimators=50, n_jobs=-1)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf = RandomForestClassifier(n_estimators=50, min_samples_leaf=20, n_jobs=-1)\n",
    "rf.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pltvid\n",
    "\n",
    "dpi = 300\n",
    "camera = pltvid.Capture(dpi=dpi)\n",
    "max = 10\n",
    "for depth in range(1,max+1):\n",
    "    t = DecisionTreeClassifier(max_depth=depth)\n",
    "    t.fit(X, y)\n",
    "\n",
    "    fig,ax = plt.subplots(1,1, figsize=(4,3.5), dpi=dpi)\n",
    "    decision_boundaries(t, X, y, \n",
    "           feature_names=['proline', 'flavanoid'], target_name=\"wine\",\n",
    "           ax=ax)\n",
    "    plt.title(f\"Wine tree depth {depth}\")\n",
    "    plt.tight_layout()\n",
    "    if depth>=max:\n",
    "        camera.snap(8)\n",
    "    else:\n",
    "        camera.snap()\n",
    "    # plt.show()\n",
    "\n",
    "camera.save(\"wine-dtree-maxdepth.png\", duration=500) # animated png"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Synthetic data set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def smiley(n = 1000):\n",
    "    # mouth\n",
    "    x1 = np.random.normal(1.0,.2,n).reshape(-1,1)\n",
    "    x2 = np.random.normal(0.4,.05,n).reshape(-1,1)\n",
    "    cl = np.full(shape=(n,1), fill_value=0, dtype=int)\n",
    "    d = np.hstack([x1,x2,cl])\n",
    "    data = d\n",
    "    \n",
    "    # left eye\n",
    "    x1 = np.random.normal(.7,.2,n).reshape(-1,1)\n",
    "    x2 = x1 + .3 + np.random.normal(0,.1,n).reshape(-1,1)\n",
    "    cl = np.full(shape=(n,1), fill_value=1, dtype=int)\n",
    "    d = np.hstack([x1,x2,cl])\n",
    "    data = np.vstack([data, d])\n",
    "\n",
    "    # right eye\n",
    "    x1 = np.random.normal(1.3,.2,n).reshape(-1,1)\n",
    "    x2 = np.random.normal(0.8,.1,n).reshape(-1,1)\n",
    "    x2 = x1 - .5 + .3 + np.random.normal(0,.1,n).reshape(-1,1)\n",
    "    cl = np.full(shape=(n,1), fill_value=2, dtype=int)\n",
    "    d = np.hstack([x1,x2,cl])\n",
    "    data = np.vstack([data, d])\n",
    "\n",
    "    # face outline\n",
    "    noise = np.random.normal(0,.1,n).reshape(-1,1)\n",
    "    x1 = np.linspace(0,2,n).reshape(-1,1)\n",
    "    x2 = (x1-1)**2 + noise\n",
    "    cl = np.full(shape=(n,1), fill_value=3, dtype=int)\n",
    "    d = np.hstack([x1,x2,cl])\n",
    "    data = np.vstack([data, d])\n",
    "\n",
    "    df = pd.DataFrame(data, columns=['x1','x2','class'])\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Animate num trees in RF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pltvid\n",
    "\n",
    "df = smiley(n=100)\n",
    "X = df[['x1','x2']]\n",
    "y = df['class']\n",
    "rf = RandomForestClassifier(n_estimators=10, min_samples_leaf=1, n_jobs=-1)\n",
    "rf.fit(X, y)\n",
    "\n",
    "dpi = 300\n",
    "camera = pltvid.Capture(dpi=dpi)\n",
    "max = 100\n",
    "tree_sizes = [*range(1,10)]+[*range(10,max+1,5)]\n",
    "for nt in tree_sizes:\n",
    "    np.random.seed(1) # use same bagging sets for animation\n",
    "    rf = RandomForestClassifier(n_estimators=nt, min_samples_leaf=1, n_jobs=-1)\n",
    "    rf.fit(X.values, y.values)\n",
    "\n",
    "    fig,ax = plt.subplots(1,1, figsize=(5,3.5), dpi=dpi)\n",
    "    decision_boundaries(rf, X.values, y, feature_names=['x1', 'x2'],\n",
    "                 ntiles=70, dot_w=15, boundary_markersize=.4, ax=ax)\n",
    "    plt.title(f\"Synthetic dataset, {nt} trees\")\n",
    "    plt.tight_layout()\n",
    "    if nt>=tree_sizes[-1]:\n",
    "        camera.snap(5)\n",
    "    else:\n",
    "        camera.snap()\n",
    "    # plt.show()\n",
    "\n",
    "camera.save(\"smiley-numtrees.png\", duration=500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Animate decision tree max depth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pltvid\n",
    "\n",
    "df = smiley(n=100) # more stark changes with fewer\n",
    "X = df[['x1','x2']]\n",
    "y = df['class']\n",
    "\n",
    "dpi = 300\n",
    "camera = pltvid.Capture(dpi=dpi)\n",
    "max = 10\n",
    "for depth in range(1,max+1):\n",
    "    t = DecisionTreeClassifier(max_depth=depth)\n",
    "    t.fit(X.values, y.values)\n",
    "\n",
    "    fig,ax = plt.subplots(1,1, figsize=(5,3.5), dpi=dpi)\n",
    "    decision_boundaries(t, X, y, \n",
    "               feature_names=['x1', 'x2'], target_name=\"class\",\n",
    "               colors={'scatter_edge': 'black',\n",
    "                       'tessellation_alpha':.6},\n",
    "               ax=ax)\n",
    "    plt.title(f\"Synthetic dataset, tree depth {depth}\")\n",
    "    plt.tight_layout()\n",
    "    if depth>=max:\n",
    "        camera.snap(8)\n",
    "    else:\n",
    "        camera.snap()\n",
    "    # plt.show()\n",
    "\n",
    "camera.save(\"smiley-dtree-maxdepth.png\", duration=500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Animate decision tree min samples per leaf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pltvid\n",
    "\n",
    "df = smiley(n=100)\n",
    "X = df[['x1','x2']]\n",
    "y = df['class']\n",
    "\n",
    "dpi = 300\n",
    "camera = pltvid.Capture(dpi=dpi)\n",
    "max = 20\n",
    "for leafsz in range(1,max+1):\n",
    "    t = DecisionTreeClassifier(min_samples_leaf=leafsz)\n",
    "    t.fit(X.values, y.values)\n",
    "\n",
    "    fig,ax = plt.subplots(1,1, figsize=(5,3.5), dpi=dpi)\n",
    "    decision_boundaries(t, X, y, \n",
    "               feature_names=['x1', 'x2'], target_name=\"class\",\n",
    "               colors={'scatter_edge': 'black',\n",
    "                       'tessellation_alpha':.4},\n",
    "               ax=ax)\n",
    "    plt.title(f\"Synthetic dataset, {leafsz} samples/leaf\")\n",
    "    plt.tight_layout()\n",
    "    if leafsz>=max:\n",
    "        camera.snap(8)\n",
    "    else:\n",
    "        camera.snap()\n",
    "    # plt.show()\n",
    "\n",
    "camera.save(\"smiley-dtree-minsamplesleaf.png\", duration=500)"
   ]
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}