Visualising Decision Boundaries.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adapted from http://scikit-learn.org/stable/auto_examples/svm/plot_iris.html\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def make_meshgrid(x, y, h=.02, lims=None):\n",
    "    \"\"\"Create a mesh of points to plot in\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    x: data to base x-axis meshgrid on\n",
    "    y: data to base y-axis meshgrid on\n",
    "    h: stepsize for meshgrid, optional\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    xx, yy : ndarray\n",
    "    \"\"\"\n",
    "\n",
    "    if lims is None:\n",
    "        x_min, x_max = x.min() - 1, x.max() + 1\n",
    "        y_min, y_max = y.min() - 1, y.max() + 1\n",
    "    else:\n",
    "        x_min, x_max, y_min, y_max = lims\n",
    "    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n",
    "                         np.arange(y_min, y_max, h))\n",
    "    return xx, yy\n",
    "\n",
    "\n",
    "def plot_contours(ax, clf, xx, yy, proba=False, **params):\n",
    "    \"\"\"Plot the decision boundaries for a classifier.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    ax: matplotlib axes object\n",
    "    clf: a classifier\n",
    "    xx: meshgrid ndarray\n",
    "    yy: meshgrid ndarray\n",
    "    params: dictionary of params to pass to contourf, optional\n",
    "    \"\"\"\n",
    "    if proba:\n",
    "        Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:,-1]\n",
    "        Z = Z.reshape(xx.shape)\n",
    "        out = ax.imshow(Z,extent=(np.min(xx), np.max(xx), np.min(yy), np.max(yy)), origin='lower', vmin=0, vmax=1, **params)\n",
    "        ax.contour(xx, yy, Z, levels=[0.5])\n",
    "    else:\n",
    "        Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])\n",
    "        Z = Z.reshape(xx.shape)\n",
    "        out = ax.contourf(xx, yy, Z, **params)\n",
    "    return out\n",
    "\n",
    "# adapted from http://scikit-learn.org/stable/auto_examples/svm/plot_iris.html\n",
    "def plot_classifier(X, y, clf, ax=None, ticks=False, proba=False, lims=None): # assumes classifier \"clf\" is already fit\n",
    "    X0, X1 = X[:, 0], X[:, 1]\n",
    "    xx, yy = make_meshgrid(X0, X1, lims=lims)\n",
    "\n",
    "    if ax is None:\n",
    "        plt.figure()\n",
    "        ax = plt.gca()\n",
    "        show = True\n",
    "    else:\n",
    "        show = False\n",
    "\n",
    "    # can abstract some of this into a higher-level function for learners to call\n",
    "    cs = plot_contours(ax, clf, xx, yy, cmap=plt.cm.coolwarm, alpha=0.8, proba=proba)\n",
    "    if proba:\n",
    "        cbar = plt.colorbar(cs)\n",
    "        cbar.ax.set_ylabel('probability of red $\\Delta$ class', fontsize=20, rotation=270, labelpad=30)\n",
    "        cbar.ax.tick_params(labelsize=14)\n",
    "    #ax.scatter(X0, X1, c=y, cmap=plt.cm.coolwarm, s=30, edgecolors='k', linewidth=1)\n",
    "    labels = np.unique(y)\n",
    "    if len(labels) == 2:\n",
    "        ax.scatter(X0[y==labels[0]], X1[y==labels[0]], cmap=plt.cm.coolwarm, s=60, c='b', marker='o', edgecolors='k')\n",
    "        ax.scatter(X0[y==labels[1]], X1[y==labels[1]], cmap=plt.cm.coolwarm, s=60, c='r', marker='^', edgecolors='k')\n",
    "    else:\n",
    "        ax.scatter(X0, X1, c=y, cmap=plt.cm.coolwarm, s=50, edgecolors='k', linewidth=1)\n",
    "\n",
    "    ax.set_xlim(xx.min(), xx.max())\n",
    "    ax.set_ylim(yy.min(), yy.max())\n",
    "#     ax.set_xlabel(data.feature_names[0])\n",
    "#     ax.set_ylabel(data.feature_names[1])\n",
    "    if ticks:\n",
    "        ax.set_xticks(())\n",
    "        ax.set_yticks(())\n",
    "#     ax.set_title(title)\n",
    "    if show:\n",
    "        plt.show()\n",
    "    else:\n",
    "        return ax\n",
    "\n",
    "def plot_4_classifiers(X, y, clfs):\n",
    "\n",
    "    # Set-up 2x2 grid for plotting.\n",
    "    fig, sub = plt.subplots(2, 2)\n",
    "    plt.subplots_adjust(wspace=0.2, hspace=0.2)\n",
    "\n",
    "    for clf, ax, title in zip(clfs, sub.flatten(), (\"(1)\", \"(2)\", \"(3)\", \"(4)\")):\n",
    "        # clf.fit(X, y)\n",
    "        plot_classifier(X, y, clf, ax, ticks=True)\n",
    "        ax.set_title(title)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import sklearn.datasets\n",
    "#wine = sklearn.datasets.load_wine()\n",
    "#X = wine.data[:,:2]\n",
    "#y = wine.target\n",
    "\n",
    "y = np.array([ True,  True, False,  True,  True,  True, False, False,  True,\n",
    "              False,  True,  True, False, False,  True, False,  True,  True,\n",
    "              True, False,  True,  True,  True, False,  True,  True,  True,\n",
    "              True,  True,  True,  True,  True, False,  True,  True,  True,\n",
    "              False, False,  True,  True,  True,  True, False, False, False,\n",
    "              True,  True,  True, False,  True])\n",
    "\n",
    "X = np.array([[11.45,  2.4 ],\n",
    "              [13.62,  4.95],\n",
    "              [13.88,  1.89],\n",
    "              [12.42,  2.55],\n",
    "              [12.81,  2.31],\n",
    "              [12.58,  1.29],\n",
    "              [13.83,  1.57],\n",
    "              [13.07,  1.5 ],\n",
    "              [12.7 ,  3.55],\n",
    "              [13.77,  1.9 ],\n",
    "              [12.84,  2.96],\n",
    "              [12.37,  1.63],\n",
    "              [13.51,  1.8 ],\n",
    "              [13.87,  1.9 ],\n",
    "              [12.08,  1.39],\n",
    "              [13.58,  1.66],\n",
    "              [13.08,  3.9 ],\n",
    "              [11.79,  2.13],\n",
    "              [12.45,  3.03],\n",
    "              [13.68,  1.83],\n",
    "              [13.52,  3.17],\n",
    "              [13.5 ,  3.12],\n",
    "              [12.87,  4.61],\n",
    "              [14.02,  1.68],\n",
    "              [12.29,  3.17],\n",
    "              [12.08,  1.13],\n",
    "              [12.7 ,  3.87],\n",
    "              [11.03,  1.51],\n",
    "              [13.32,  3.24],\n",
    "              [14.13,  4.1 ],\n",
    "              [13.49,  1.66],\n",
    "              [11.84,  2.89],\n",
    "              [13.05,  2.05],\n",
    "              [12.72,  1.81],\n",
    "              [12.82,  3.37],\n",
    "              [13.4 ,  4.6 ],\n",
    "              [14.22,  3.99],\n",
    "              [13.72,  1.43],\n",
    "              [12.93,  2.81],\n",
    "              [11.64,  2.06],\n",
    "              [12.29,  1.61],\n",
    "              [11.65,  1.67],\n",
    "              [13.28,  1.64],\n",
    "              [12.93,  3.8 ],\n",
    "              [13.86,  1.35],\n",
    "              [11.82,  1.72],\n",
    "              [12.37,  1.17],\n",
    "              [12.42,  1.61],\n",
    "              [13.9 ,  1.68],\n",
    "              [14.16,  2.51]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\hazrulnizam.sidek\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\svm\\_base.py:947: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n",
      "  \"the number of iterations.\", ConvergenceWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.svm import SVC, LinearSVC\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "# Define the classifiers\n",
    "classifiers = [LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True, \n",
    "                                  intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,\n",
    "                                  penalty='l2', random_state=None, solver='liblinear', tol=0.0001,\n",
    "                                  verbose=0, warm_start=False), \n",
    "               LinearSVC(), \n",
    "               SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,\n",
    "                   decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',\n",
    "                   max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
    "                   tol=0.001, verbose=False), \n",
    "               KNeighborsClassifier()]\n",
    "\n",
    "# Fit the classifiers\n",
    "for c in classifiers:\n",
    "    c.fit(X, y)\n",
    "\n",
    "# Plot the classifiers\n",
    "plot_4_classifiers(X, y, classifiers)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.74\n",
      "0.88\n",
      "0.92\n",
      "0.92\n"
     ]
    }
   ],
   "source": [
    "for clf in classifiers:\n",
    "    print(clf.score(X,y))"
   ]
  },
  {
   "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}