Support Vector Machine.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Support Vector Machine (SVM)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: scikit-learn==0.23.1 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (0.23.1)\n",
      "Requirement already satisfied: scipy>=0.19.1 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from scikit-learn==0.23.1) (1.7.3)\n",
      "Requirement already satisfied: threadpoolctl>=2.0.0 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from scikit-learn==0.23.1) (3.1.0)\n",
      "Requirement already satisfied: numpy>=1.13.3 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from scikit-learn==0.23.1) (1.21.4)\n",
      "Requirement already satisfied: joblib>=0.11 in /home/jupyterlab/conda/envs/python/lib/python3.7/site-packages (from scikit-learn==0.23.1) (1.1.0)\n"
     ]
    }
   ],
   "source": [
    "!pip install scikit-learn==0.23.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import pylab as pl\n",
    "import numpy as np\n",
    "import scipy.optimize as opt\n",
    "from sklearn import preprocessing\n",
    "from sklearn.model_selection import train_test_split\n",
    "%matplotlib inline \n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "tags": []
   },
   "source": [
    "<h2 id=\"load_dataset\">Load the Cancer data</h2>\n",
    "The example is based on a dataset that is publicly available from the UCI Machine Learning Repository (Asuncion and Newman, 2007)[http://mlearn.ics.uci.edu/MLRepository.html]. The dataset consists of several hundred human cell sample records, each of which contains the values of a set of cell characteristics. The fields in each record are:\n",
    "\n",
    "| Field name  | Description                 |\n",
    "| ----------- | --------------------------- |\n",
    "| ID          | Clump thickness             |\n",
    "| Clump       | Clump thickness             |\n",
    "| UnifSize    | Uniformity of cell size     |\n",
    "| UnifShape   | Uniformity of cell shape    |\n",
    "| MargAdh     | Marginal adhesion           |\n",
    "| SingEpiSize | Single epithelial cell size |\n",
    "| BareNuc     | Bare nuclei                 |\n",
    "| BlandChrom  | Bland chromatin             |\n",
    "| NormNucl    | Normal nucleoli             |\n",
    "| Mit         | Mitoses                     |\n",
    "| Class       | Benign or malignant         |\n",
    "\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "For the purposes of this example, we're using a dataset that has a relatively small number of predictors in each record. To download the data, we will use `!wget` to download it from IBM Object Storage.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2022-02-07 21:21:11--  https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%203/data/cell_samples.csv\n",
      "Resolving cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud (cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud)... 169.63.118.104\n",
      "Connecting to cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud (cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud)|169.63.118.104|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 19975 (20K) [text/csv]\n",
      "Saving to: ‘cell_samples.csv’\n",
      "\n",
      "cell_samples.csv    100%[===================>]  19.51K  --.-KB/s    in 0s      \n",
      "\n",
      "2022-02-07 21:21:11 (215 MB/s) - ‘cell_samples.csv’ saved [19975/19975]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Click here and press Shift+Enter\n",
    "!wget -O cell_samples.csv https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%203/data/cell_samples.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "## Load Data From CSV File\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "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>ID</th>\n",
       "      <th>Clump</th>\n",
       "      <th>UnifSize</th>\n",
       "      <th>UnifShape</th>\n",
       "      <th>MargAdh</th>\n",
       "      <th>SingEpiSize</th>\n",
       "      <th>BareNuc</th>\n",
       "      <th>BlandChrom</th>\n",
       "      <th>NormNucl</th>\n",
       "      <th>Mit</th>\n",
       "      <th>Class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1000025</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1002945</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>7</td>\n",
       "      <td>10</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1015425</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1016277</td>\n",
       "      <td>6</td>\n",
       "      <td>8</td>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>7</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1017023</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        ID  Clump  UnifSize  UnifShape  MargAdh  SingEpiSize BareNuc  \\\n",
       "0  1000025      5         1          1        1            2       1   \n",
       "1  1002945      5         4          4        5            7      10   \n",
       "2  1015425      3         1          1        1            2       2   \n",
       "3  1016277      6         8          8        1            3       4   \n",
       "4  1017023      4         1          1        3            2       1   \n",
       "\n",
       "   BlandChrom  NormNucl  Mit  Class  \n",
       "0           3         1    1      2  \n",
       "1           3         2    1      2  \n",
       "2           3         1    1      2  \n",
       "3           3         7    1      2  \n",
       "4           3         1    1      2  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cell_df = pd.read_csv(\"cell_samples.csv\")\n",
    "cell_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ID field contains the patient identifiers. The characteristics of the cell samples from each patient are contained in fields Clump to Mit. The values are graded from 1 to 10, with 1 being the closest to benign.\n",
    "\n",
    "The Class field contains the diagnosis, as confirmed by separate medical procedures, as to whether the samples are benign (value = 2) or malignant (value = 4).\n",
    "\n",
    "Let's look at the distribution of the classes based on Clump thickness and Uniformity of cell size:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = cell_df[cell_df['Class'] == 4][0:50].plot(kind='scatter', x='Clump', y='UnifSize', color='DarkBlue', label='malignant');\n",
    "cell_df[cell_df['Class'] == 2][0:50].plot(kind='scatter', x='Clump', y='UnifSize', color='Yellow', label='benign', ax=ax);\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data pre-processing and selection\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's first look at columns data types:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ID              int64\n",
       "Clump           int64\n",
       "UnifSize        int64\n",
       "UnifShape       int64\n",
       "MargAdh         int64\n",
       "SingEpiSize     int64\n",
       "BareNuc        object\n",
       "BlandChrom      int64\n",
       "NormNucl        int64\n",
       "Mit             int64\n",
       "Class           int64\n",
       "dtype: object"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cell_df.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like the **BareNuc** column includes some values that are not numerical. We can drop those rows:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ID             int64\n",
       "Clump          int64\n",
       "UnifSize       int64\n",
       "UnifShape      int64\n",
       "MargAdh        int64\n",
       "SingEpiSize    int64\n",
       "BareNuc        int64\n",
       "BlandChrom     int64\n",
       "NormNucl       int64\n",
       "Mit            int64\n",
       "Class          int64\n",
       "dtype: object"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cell_df = cell_df[pd.to_numeric(cell_df['BareNuc'], errors='coerce').notnull()]\n",
    "cell_df['BareNuc'] = cell_df['BareNuc'].astype('int')\n",
    "cell_df.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  1,  1,  1,  2,  1,  3,  1,  1],\n",
       "       [ 5,  4,  4,  5,  7, 10,  3,  2,  1],\n",
       "       [ 3,  1,  1,  1,  2,  2,  3,  1,  1],\n",
       "       [ 6,  8,  8,  1,  3,  4,  3,  7,  1],\n",
       "       [ 4,  1,  1,  3,  2,  1,  3,  1,  1]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "feature_df = cell_df[['Clump', 'UnifSize', 'UnifShape', 'MargAdh', 'SingEpiSize', 'BareNuc', 'BlandChrom', 'NormNucl', 'Mit']]\n",
    "X = np.asarray(feature_df)\n",
    "X[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want the model to predict the value of Class (that is, benign (=2) or malignant (=4)). As this field can have one of only two possible values, we need to change its measurement level to reflect this.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 2, 2, 2, 2])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cell_df['Class'] = cell_df['Class'].astype('int')\n",
    "y = np.asarray(cell_df['Class'])\n",
    "y [0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train/Test dataset\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We split our dataset into train and test set:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train set: (546, 9) (546,)\n",
      "Test set: (137, 9) (137,)\n"
     ]
    }
   ],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=4)\n",
    "print ('Train set:', X_train.shape,  y_train.shape)\n",
    "print ('Test set:', X_test.shape,  y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"modeling\">Modeling (SVM with Scikit-learn)</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The SVM algorithm offers a choice of kernel functions for performing its processing. Basically, mapping data into a higher dimensional space is called kernelling. The mathematical function used for the transformation is known as the kernel function, and can be of different types, such as:\n",
    "\n",
    "```\n",
    "1.Linear\n",
    "2.Polynomial\n",
    "3.Radial basis function (RBF)\n",
    "4.Sigmoid\n",
    "```\n",
    "\n",
    "Each of these functions has its characteristics, its pros and cons, and its equation, but as there's no easy way of knowing which function performs best with any given dataset. We usually choose different functions in turn and compare the results. Let's just use the default, RBF (Radial Basis Function) for now.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SVC()"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import svm\n",
    "clf = svm.SVC(kernel='rbf')\n",
    "clf.fit(X_train, y_train) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After being fitted, the model can then be used to predict new values:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4, 2, 4, 2])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yhat = clf.predict(X_test)\n",
    "yhat [0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"evaluation\">Evaluation</h2>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import classification_report, confusion_matrix\n",
    "import itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion matrix, without normalization')\n",
    "\n",
    "    print(cm)\n",
    "\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           2       1.00      0.94      0.97        90\n",
      "           4       0.90      1.00      0.95        47\n",
      "\n",
      "    accuracy                           0.96       137\n",
      "   macro avg       0.95      0.97      0.96       137\n",
      "weighted avg       0.97      0.96      0.96       137\n",
      "\n",
      "Confusion matrix, without normalization\n",
      "[[85  5]\n",
      " [ 0 47]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compute confusion matrix\n",
    "cnf_matrix = confusion_matrix(y_test, yhat, labels=[2,4])\n",
    "np.set_printoptions(precision=2)\n",
    "\n",
    "print (classification_report(y_test, yhat))\n",
    "\n",
    "# Plot non-normalized confusion matrix\n",
    "plt.figure()\n",
    "plot_confusion_matrix(cnf_matrix, classes=['Benign(2)','Malignant(4)'],normalize= False,  title='Confusion matrix')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also easily use the **f1\\_score** from sklearn library:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9639038982104676"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "f1_score(y_test, yhat, average='weighted') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try the jaccard index for accuracy:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9444444444444444"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import jaccard_score\n",
    "jaccard_score(y_test, yhat,pos_label=2)"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}