{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from fastai import *\n",
    "from fastai.vision import *\n",
    "\n",
    "path = Path(\"../pap_smear\")\n",
    "classes = [\"normal\", \"abnormal\"]\n",
    "    \n",
    "tfms = get_transforms(flip_vert=True, max_warp=0.0, max_zoom=0.5)\n",
    "data = (ImageList.from_folder(path=path)\n",
    "       .filter_by_func(lambda fname: \"-d\" not in fname.name)\n",
    "       .split_by_rand_pct(valid_pct=0.2)\n",
    "       .label_from_func(lambda fname: classes.index(fname.parts[-2].split(\"_\")[0]))\n",
    "       .transform(tfms, size=32)\n",
    "       .databunch(bs=8)\n",
    "       .normalize(imagenet_stats))\n",
    "data.show_batch(rows=2, figsize=(5, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import joblib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(734, 32, 32, 3) (734,)\n"
     ]
    }
   ],
   "source": [
    "train_images = []\n",
    "train_labels = []\n",
    "\n",
    "for (x, y) in data.train_ds:\n",
    "    x = x.data.permute(2, 1, 0).numpy()\n",
    "    y = y.obj\n",
    "    train_images.append(x)\n",
    "    train_labels.append(y)\n",
    "\n",
    "train_images = np.array(train_images)\n",
    "train_labels = np.array(train_labels)\n",
    "print(train_images.shape, train_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(183, 32, 32, 3) (183,)\n"
     ]
    }
   ],
   "source": [
    "val_images = []\n",
    "val_labels = []\n",
    "\n",
    "for (x, y) in data.valid_ds:\n",
    "    x = x.data.permute(2, 1, 0).numpy()\n",
    "    y = y.obj\n",
    "    val_images.append(x)\n",
    "    val_labels.append(y)\n",
    "\n",
    "val_images = np.array(val_images)\n",
    "val_labels = np.array(val_labels)\n",
    "print(val_images.shape, val_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.base import BaseEstimator, TransformerMixin\n",
    "from skimage.feature import hog\n",
    "from skimage.io import imread\n",
    "from skimage.transform import rescale\n",
    " \n",
    "class RGB2GrayTransformer(BaseEstimator, TransformerMixin):\n",
    "    \"\"\"\n",
    "    Convert an array of RGB images to grayscale\n",
    "    \"\"\"\n",
    " \n",
    "    def __init__(self):\n",
    "        pass\n",
    " \n",
    "    def fit(self, X, y=None):\n",
    "        \"\"\"returns itself\"\"\"\n",
    "        return self\n",
    " \n",
    "    def transform(self, X, y=None):\n",
    "        \"\"\"perform the transformation and return an array\"\"\"\n",
    "        return np.array([skimage.color.rgb2gray(img) for img in X])\n",
    " \n",
    " \n",
    "class HogTransformer(BaseEstimator, TransformerMixin):\n",
    "    \"\"\"\n",
    "    Expects an array of 2d arrays (1 channel images)\n",
    "    Calculates hog features for each img\n",
    "    \"\"\"\n",
    " \n",
    "    def __init__(self, y=None, orientations=9,\n",
    "                 pixels_per_cell=(8, 8),\n",
    "                 cells_per_block=(3, 3), block_norm='L2-Hys'):\n",
    "        self.y = y\n",
    "        self.orientations = orientations\n",
    "        self.pixels_per_cell = pixels_per_cell\n",
    "        self.cells_per_block = cells_per_block\n",
    "        self.block_norm = block_norm\n",
    " \n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    " \n",
    "    def transform(self, X, y=None):\n",
    " \n",
    "        def local_hog(X):\n",
    "            return hog(X,\n",
    "                       orientations=self.orientations,\n",
    "                       pixels_per_cell=self.pixels_per_cell,\n",
    "                       cells_per_block=self.cells_per_block,\n",
    "                       block_norm=self.block_norm)\n",
    " \n",
    "        try: # parallel\n",
    "            return np.array([local_hog(img) for img in X])\n",
    "        except:\n",
    "            return np.array([local_hog(img) for img in X])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.model_selection import cross_val_predict\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "import skimage\n",
    " \n",
    "# create an instance of each transformer\n",
    "grayify = RGB2GrayTransformer()\n",
    "hogify = HogTransformer(\n",
    "    pixels_per_cell=(8, 8),\n",
    "    cells_per_block=(2,2),\n",
    "    orientations=9,\n",
    "    block_norm='L2-Hys'\n",
    ")\n",
    "scalify = StandardScaler()\n",
    " \n",
    "# call fit_transform on each transform converting X_train step by step\n",
    "X_train_gray = grayify.fit_transform(train_images)\n",
    "X_train_hog = hogify.fit_transform(X_train_gray)\n",
    "X_train_prepared = scalify.fit_transform(X_train_hog)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(734, 324)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train_prepared.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test_gray = grayify.transform(val_images)\n",
    "X_test_hog = hogify.transform(X_test_gray)\n",
    "X_test_prepared = scalify.transform(X_test_hog)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SGD Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SGDClassifier(alpha=0.0001, average=False, class_weight=None,\n",
       "              early_stopping=False, epsilon=0.1, eta0=0.0, fit_intercept=True,\n",
       "              l1_ratio=0.15, learning_rate='optimal', loss='hinge',\n",
       "              max_iter=1000, n_iter_no_change=5, n_jobs=None, penalty='l2',\n",
       "              power_t=0.5, random_state=42, shuffle=True, tol=0.001,\n",
       "              validation_fraction=0.1, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import SGDClassifier\n",
    "sgd_clf = SGDClassifier(random_state=42, max_iter=1000, tol=1e-3)\n",
    "sgd_clf.fit(X_train_prepared, train_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False  True False False False  True  True False False  True  True False  True False False False  True False  True\n",
      "  True  True False  True  True  True]\n",
      "\n",
      "Percentage correct:  71.5846994535519\n"
     ]
    }
   ],
   "source": [
    "y_pred = sgd_clf.predict(X_test_prepared)\n",
    "print(np.array(y_pred == val_labels)[:25])\n",
    "print('')\n",
    "print('Percentage correct: ', 100*np.sum(y_pred == val_labels)/len(val_labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "from sklearn import metrics\n",
    "\n",
    "disp = metrics.plot_confusion_matrix(sgd_clf, X_test_prepared, val_labels)\n",
    "plt.show(disp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['sgd_clf.pkl']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joblib.dump(sgd_clf, \"sgd_clf.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy : 71.58469945355192\n",
      "Precision : 78.37837837837837\n",
      "Recall : 85.29411764705883\n",
      "Specificity : 31.914893617021278\n",
      "H-mean : 46.44954618259477\n",
      "F1 score : 81.69014084507042\n"
     ]
    }
   ],
   "source": [
    "preds = sgd_clf.predict(X_test_prepared)\n",
    "tn, fp, fn, tp = metrics.confusion_matrix(val_labels, preds).ravel()\n",
    "sens = (tp / (tp + fn)) * 100\n",
    "spec = (tn / (tn + fp)) * 100\n",
    "prec = (tp / (tp + fp)) * 100\n",
    "accuracy = ((tp + tn) / (tp + tn + fn + fp)) * 100\n",
    "h_mean = 2 * ((sens * spec) / (sens + spec))\n",
    "f1 = 2 * ((prec * sens) / (prec + sens))\n",
    "\n",
    "print(f\"Accuracy : {accuracy}\\nPrecision : {prec}\\nRecall : {sens}\\nSpecificity : {spec}\\nH-mean : {h_mean}\\nF1 score : {f1}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SVM Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,\n",
       "    decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf',\n",
       "    max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
       "    tol=0.001, verbose=False)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.svm import SVC\n",
    "svm_clf = SVC(kernel=\"rbf\")\n",
    "svm_clf.fit(X_train_prepared, train_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True  True False  True False  True  True False False  True  True  True  True False False  True  True False  True\n",
      "  True  True False  True  True  True]\n",
      "\n",
      "Percentage correct:  76.50273224043715\n"
     ]
    }
   ],
   "source": [
    "y_pred = svm_clf.predict(X_test_prepared)\n",
    "print(np.array(y_pred == val_labels)[:25])\n",
    "print('')\n",
    "print('Percentage correct: ', 100*np.sum(y_pred == val_labels)/len(val_labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "disp = metrics.plot_confusion_matrix(svm_clf, X_test_prepared, val_labels)\n",
    "plt.show(disp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['svm_clf.pkl']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joblib.dump(svm_clf, \"svm_clf.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy : 76.50273224043715\n",
      "Precision : 76.27118644067797\n",
      "Recall : 99.26470588235294\n",
      "Specificity : 10.638297872340425\n",
      "H-mean : 19.217081850533805\n",
      "F1 score : 86.26198083067092\n"
     ]
    }
   ],
   "source": [
    "preds = svm_clf.predict(X_test_prepared)\n",
    "tn, fp, fn, tp = metrics.confusion_matrix(val_labels, preds).ravel()\n",
    "sens = (tp / (tp + fn)) * 100\n",
    "spec = (tn / (tn + fp)) * 100\n",
    "prec = (tp / (tp + fp)) * 100\n",
    "accuracy = ((tp + tn) / (tp + tn + fn + fp)) * 100\n",
    "h_mean = 2 * ((sens * spec) / (sens + spec))\n",
    "f1 = 2 * ((prec * sens) / (prec + sens))\n",
    "\n",
    "print(f\"Accuracy : {accuracy}\\nPrecision : {prec}\\nRecall : {sens}\\nSpecificity : {spec}\\nH-mean : {h_mean}\\nF1 score : {f1}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## KNN Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "                     metric_params=None, n_jobs=None, n_neighbors=5, p=2,\n",
       "                     weights='uniform')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier as knn\n",
    "\n",
    "knn_clf = knn()\n",
    "knn_clf.fit(X_train_prepared, train_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True  True False  True False  True  True  True False  True  True False  True False False  True  True  True  True\n",
      "  True  True False  True  True False]\n",
      "\n",
      "Percentage correct:  78.14207650273224\n"
     ]
    }
   ],
   "source": [
    "y_pred = knn_clf.predict(X_test_prepared)\n",
    "print(np.array(y_pred == val_labels)[:25])\n",
    "print('')\n",
    "print('Percentage correct: ', 100*np.sum(y_pred == val_labels)/len(val_labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "disp = metrics.plot_confusion_matrix(knn_clf, X_test_prepared, val_labels)\n",
    "plt.show(disp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['knn_clf.pkl']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joblib.dump(knn_clf, \"knn_clf.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy : 78.14207650273224\n",
      "Precision : 79.26829268292683\n",
      "Recall : 95.58823529411765\n",
      "Specificity : 27.659574468085108\n",
      "H-mean : 42.90429042904291\n",
      "F1 score : 86.66666666666666\n"
     ]
    }
   ],
   "source": [
    "preds = knn_clf.predict(X_test_prepared)\n",
    "tn, fp, fn, tp = metrics.confusion_matrix(val_labels, preds).ravel()\n",
    "sens = (tp / (tp + fn)) * 100\n",
    "spec = (tn / (tn + fp)) * 100\n",
    "prec = (tp / (tp + fp)) * 100\n",
    "accuracy = ((tp + tn) / (tp + tn + fn + fp)) * 100\n",
    "h_mean = 2 * ((sens * spec) / (sens + spec))\n",
    "f1 = 2 * ((prec * sens) / (prec + sens))\n",
    "\n",
    "print(f\"Accuracy : {accuracy}\\nPrecision : {prec}\\nRecall : {sens}\\nSpecificity : {spec}\\nH-mean : {h_mean}\\nF1 score : {f1}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Forest Classier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, ccp_alpha=0.0, class_weight=None,\n",
       "                       criterion='gini', max_depth=None, max_features='auto',\n",
       "                       max_leaf_nodes=None, max_samples=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=1, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, n_estimators=100,\n",
       "                       n_jobs=None, oob_score=False, random_state=None,\n",
       "                       verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "rf_clf = RandomForestClassifier()\n",
    "rf_clf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, ccp_alpha=0.0, class_weight=None,\n",
       "                       criterion='gini', max_depth=None, max_features='auto',\n",
       "                       max_leaf_nodes=None, max_samples=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=1, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, n_estimators=100,\n",
       "                       n_jobs=None, oob_score=False, random_state=None,\n",
       "                       verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf_clf.fit(X_train_prepared, train_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7486338797814208"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "preds = rf_clf.predict(X_test_prepared)\n",
    "metrics.accuracy_score(val_labels, preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x1439ed278>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "metrics.plot_confusion_matrix(rf_clf, X_test_prepared, val_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rf_clf.pkl']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joblib.dump(rf_clf, \"rf_clf.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy : 74.86338797814209\n",
      "Precision : 75.56818181818183\n",
      "Recall : 97.79411764705883\n",
      "Specificity : 8.51063829787234\n",
      "H-mean : 15.658572479764532\n",
      "F1 score : 85.25641025641026\n"
     ]
    }
   ],
   "source": [
    "preds = rf_clf.predict(X_test_prepared)\n",
    "tn, fp, fn, tp = metrics.confusion_matrix(val_labels, preds).ravel()\n",
    "sens = (tp / (tp + fn)) * 100\n",
    "spec = (tn / (tn + fp)) * 100\n",
    "prec = (tp / (tp + fp)) * 100\n",
    "accuracy = ((tp + tn) / (tp + tn + fn + fp)) * 100\n",
    "h_mean = 2 * ((sens * spec) / (sens + spec))\n",
    "f1 = 2 * ((prec * sens) / (prec + sens))\n",
    "\n",
    "print(f\"Accuracy : {accuracy}\\nPrecision : {prec}\\nRecall : {sens}\\nSpecificity : {spec}\\nH-mean : {h_mean}\\nF1 score : {f1}\")"
   ]
  },
  {
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}