Dummy Classifier Notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dummy Classifier "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is a `DummyClassifier`?\n",
    "\n",
    "DummyClassifier is a classifier that makes predictions using simple rules, which can be\n",
    "useful as a baseline for comparison against actual classifiers, especially with imbalanced classes(where the class distribution is not equal or close to equal, and is instead biased or skewed).\n",
    "\n",
    "A dummy classifier is basically a classifier which doesn’t even look at the training data while classification, but follows just a rule of thumb or strategy that we instruct it to use while classifying. It is done by including the strategy we want in the strategy parameter of the `DummyClassifier`.The main notion behind using a dummy classifier is that a classifier which is based on an analytic approach to do better than random guessing approach.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strategies used in Dummy Classifier\n",
    "\n",
    "The scikit-learn `DummyClassifier` class implements several strategies for random guessing classifiers. \n",
    "The strategies are as follows:\n",
    "\n",
    "- stratified : This strategy generates the prediction using the training set's class distribution\n",
    "- most_frequent : This always predicts the most frequent label in training set.\n",
    "- prior : This predicts the class that maximises the class prior.\n",
    "- uniform : This generates predictions uniformly at random\n",
    "- constant : Always predicts a constant label which is user defined. This is specificaly usefull for metrics that evaluate a non-majority class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ## Explaination through Implementation\n",
    " \n",
    "The dummy classifier gives measure of \"baseline\" performance--i.e. the success rate one should expect to achieve even if simply guessing.\n",
    "\n",
    "If one wishes to determine whether a given object possesses or does not possess a certain property. After analyzing a large number of the objects it is found that 90% contain the target property, then guessing that every future instance of the object possesses the target property gives a 90% likelihood of guessing correctly. Structuring these guesses is equivalent to using the `most_frequent` method in dummy clasifier\n",
    "\n",
    "Because many machine learning tasks attempt to increase the success rate of (e.g.) classification tasks, evaluating the baseline success rate can afford a floor value for the minimal value one's classifier should out-perform. \n",
    "\n",
    "If one trains a dummy classifier with the `stratified` parameter using the data discussed above, that classifier will predict that there is a 90% probability that each object it encounters possesses the target property. This is different from training a dummy classifier with the `most_frequent` parameter, as the latter would guess that all future objects possess the target property. Here's some code to illustrate:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import pandas as pd \n",
    "import matplotlib.pyplot as plt  \n",
    "import seaborn as sns "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>Pregnancies</th>\n",
       "      <th>Glucose</th>\n",
       "      <th>BloodPressure</th>\n",
       "      <th>SkinThickness</th>\n",
       "      <th>Insulin</th>\n",
       "      <th>BMI</th>\n",
       "      <th>DiabetesPedigreeFunction</th>\n",
       "      <th>Age</th>\n",
       "      <th>Outcome</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6</td>\n",
       "      <td>148</td>\n",
       "      <td>72</td>\n",
       "      <td>35</td>\n",
       "      <td>0</td>\n",
       "      <td>33.6</td>\n",
       "      <td>0.627</td>\n",
       "      <td>50</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>8</td>\n",
       "      <td>183</td>\n",
       "      <td>64</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>23.3</td>\n",
       "      <td>0.672</td>\n",
       "      <td>32</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>89</td>\n",
       "      <td>66</td>\n",
       "      <td>23</td>\n",
       "      <td>94</td>\n",
       "      <td>28.1</td>\n",
       "      <td>0.167</td>\n",
       "      <td>21</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    Pregnancies  Glucose  BloodPressure  SkinThickness  Insulin   BMI  \\\n",
       "Id                                                                      \n",
       "0             6      148             72             35        0  33.6   \n",
       "2             8      183             64              0        0  23.3   \n",
       "3             1       89             66             23       94  28.1   \n",
       "\n",
       "    DiabetesPedigreeFunction  Age  Outcome  \n",
       "Id                                          \n",
       "0                      0.627   50        1  \n",
       "2                      0.672   32        1  \n",
       "3                      0.167   21        0  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "df_train = pd.read_csv(\"C:/Users/sshre/OneDrive/Documents/DATA SCIENCE/train.csv\")\n",
    "df_train.set_index(\"Id\").head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df_train.drop([\"Outcome\"],axis=1)\n",
    "y = df_train[\"Outcome\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dividing the data set into training and test data for analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checking the dummyclassifier performance with different strategies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6276595744680851\n",
      "0.5638297872340425\n",
      "0.574468085106383\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.dummy import DummyClassifier\n",
    "strategies = ['most_frequent', 'stratified', 'uniform'] \n",
    "  \n",
    "test_scores = [] \n",
    "for s in strategies: \n",
    "     \n",
    "    dclf = DummyClassifier(strategy = s, random_state = 0) \n",
    "    dclf.fit(X_train, y_train)  \n",
    "    prediction=dclf.predict(X_test)\n",
    "    score=(accuracy_score(y_test,prediction)) \n",
    "    test_scores.append(score)\n",
    "    print(score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotting the performace score of the dummyclassifier "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEHCAYAAAC0pdErAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAc2ElEQVR4nO3dfZxcVZ3n8c+XhCAIyEMaN5JAMpqIjsNTyigyKGGEiU/JzoIRRlfjiBlXI+OM4AvXh3GCzgw+jLtoZjWwgIzyoOhAQCSgC4gokopAIGEimQRMiy9pkyAgCgS++8e9DZXK7U6R9O1KJ9/361WvrnPuuad+1dVdvzrn1j1XtomIiGi3S7cDiIiI7VMSREREVEqCiIiISkkQERFRKQkiIiIqje52AENl7NixnjhxYrfDiIgYUZYuXfob2z1V23aYBDFx4kSazWa3w4iIGFEk3T/QtkwxRUREpSSIiIiolAQRERGVak0QkmZIWilplaQzB2gzW9IKScslXdy2bW9Jv5T05TrjjIiIzdV2kFrSKGABcDzQCyyRtMj2ipY2k4GPAkfb3iDpgLZuzgJuqivGiIgYWJ0jiGnAKturbT8BXArMamvzXmCB7Q0Ath/s3yBpKvBC4LoaY4yIiAHUmSAOBNa2lHvLulZTgCmSbpF0q6QZAJJ2Ab4AnDHYA0iaK6kpqdnX1zeEoUdERJ0JQhV17WuLjwYmA8cCpwDnSdoHeD9wje21DML2QtsN242ensrzPCIiYivVeaJcLzChpTweeKCiza22nwTWSFpJkTCOAo6R9H5gT2CMpEdtVx7ojoiIoVfnCGIJMFnSJEljgJOBRW1trgCmA0gaSzHltNr2220fZHsicDpwUZJDRMTwqi1B2N4IzAMWA/cA37S9XNJ8STPLZouBdZJWADcAZ9heV1dMERHROe0olxxtNBrOWkwREc+NpKW2G1XbciZ1RERUSoKIiIhKSRAREVEpCSIiIiolQURERKUkiIiIqJQEERERlZIgIiKiUhJERERUSoKIiIhKSRAREVEpCSIiIiolQURERKUkiIiIqJQEERERlZIgIiKiUhJERERUqjVBSJohaaWkVZIqryktabakFZKWS7q4rDtY0lJJd5T176szzoiI2NzoujqWNApYABwP9AJLJC2yvaKlzWTgo8DRtjdIOqDc9CvgNbYfl7QncHe57wN1xRsREZuqcwQxDVhle7XtJ4BLgVltbd4LLLC9AcD2g+XPJ2w/XrbZreY4IyKiQp1vvAcCa1vKvWVdqynAFEm3SLpV0oz+DZImSFpW9nF21ehB0lxJTUnNvr6+Gp5CRMTOq84EoYo6t5VHA5OBY4FTgPMk7QNge63tQ4GXAO+S9MLNOrMX2m7YbvT09Axp8BERO7s6E0QvMKGlPB5oHwX0AlfaftL2GmAlRcJ4RjlyWA4cU2OsERHRps4EsQSYLGmSpDHAycCitjZXANMBJI2lmHJaLWm8pN3L+n2BoymSR0REDJPavsVke6OkecBiYBRwvu3lkuYDTduLym0nSFoBPAWcYXudpOOBL0gyxVTV523fVVesI9Uv1j3G6Zffyc/u38CRB+/L5086jIP236PbYUXEDkJ2+2GBkanRaLjZbHY7jGE1+6s/4bY1658pT5u0H9/866O6GFFEjDSSltpuVG3L10dHsJ/dv2HQckTEtkiCGMGOPHjfQcsREdsiCWIE+/xJhzFt0n6M3kVMm7Qfnz/psG6HFBE7kNoOUkf9Dtp/jxxziIjaZAQRERGVkiAiIqJSEkRERFRKgoiIiEpJEBERUSkJIiIiKiVBREREpSSIiIiolAQRERGVkiAiIqJSEkRERFRKgoiIiEpJEBERUanWBCFphqSVklZJOnOANrMlrZC0XNLFZd3hkn5S1i2T9LY644yIiM3Vtty3pFHAAuB4oBdYImmR7RUtbSYDHwWOtr1B0gHlpseAd9q+V9KLgKWSFtt+qK54IyJiU3WOIKYBq2yvtv0EcCkwq63Ne4EFtjcA2H6w/Plz2/eW9x8AHgR6aow1IiLa1JkgDgTWtpR7y7pWU4Apkm6RdKukGe2dSJoGjAH+s2LbXElNSc2+vr4hDD0iIupMEKqoc1t5NDAZOBY4BThP0j7PdCCNA/4NeLftpzfrzF5ou2G70dOTAUZExFCqM0H0AhNayuOBByraXGn7SdtrgJUUCQNJewPfBT5u+9Ya44yIiAp1JoglwGRJkySNAU4GFrW1uQKYDiBpLMWU0+qy/b8DF9n+Vo0xRkTEAGpLELY3AvOAxcA9wDdtL5c0X9LMstliYJ2kFcANwBm21wGzgdcCcyTdUd4OryvWiIjYnOz2wwIjU6PRcLPZ7HYYEREjiqSlthtV23ImdUREVEqCiIiISkkQERFRKQkiIiIqJUFERESlJIiIiKiUBBEREZWSICIiolISREREVEqCiIiISkkQERFRKQkiIiIqJUFERESlJIiIiKiUBBEREZWSICIiolISREREVKo1QUiaIWmlpFWSzhygzWxJKyQtl3RxS/21kh6SdHWdMUZERLXRdXUsaRSwADge6AWWSFpke0VLm8nAR4GjbW+QdEBLF58D9gD+uq4YIyJiYFscQUjqkfTV/k/ykl4uaU4HfU8DVtlebfsJ4FJgVlub9wILbG8AsP1g/wbbPwAe6expRETEUOtkiulC4CZgQlm+F/hwB/sdCKxtKfeWda2mAFMk3SLpVkkzOug3IiKGQScJ4gDbFwNPA9h+Eniqg/1UUee28mhgMnAscApwnqR9Oui7eABprqSmpGZfX1+nu0VERAc6SRC/k7Qf5Zu7pFfS2dRPL8+OOgDGAw9UtLnS9pO21wArKRJGR2wvtN2w3ejp6el0t4iI6EAnCeJ04CrgjyTdBFwCfLCD/ZYAkyVNkjQGOBlY1NbmCmA6gKSxFFNOqzuMPSIiajTot5gk7QKMongTfxnFtNGK8qDzoGxvlDQPWFz2cb7t5ZLmA03bi8ptJ0haQTFtdYbtdeVj3wwcAuwpqRd4j+3FW/tEIyLiuZHdfligrYF0q+1XD1M8W63RaLjZbHY7jIiIEUXSUtuNqm2dTDFdL6n966kREbGD6+REuXnACyQ9DvyeYprJtverNbKIiOiqThLE2NqjiIiI7c4WE4TtpyS9EXhtWXWj7WvrDSsiIrqtk6U2PgN8hOLrp6uBj0j6dN2BRUREd3UyxfQW4AjbTwFIOh/4GfDxOgOLiIju6nS5771b7u9VRyAREbF96WQE8VngZ5J+QPENpmOBT9YZVEREdF8nB6m/LukG4FUUCeKTtn9Ze2QREdFVnRykngk8avs7tr9NsXjfm+sPLSIiuqmTYxDzbf+2v2D7IeCs+kKKiIjtQScJoqpNbZcqjYiI7UMnCeJnkj4r6WBJB0n6HHB73YFFRER3dZIg5pXtrqS4LgTA+2uLKCIitgudfIvpUYqLBiFpL9udXE0uIiJGuAFHEJI+JumQ8v4YSdcBayX9WtJxwxZhRER0xWBTTH9JcY1ogHcCz6NY2fU44J9qjisiIrpssATxhJ+93NwM4GLbG20vB3btpHNJMyStlLRK0pkDtJktaYWk5ZIubql/l6R7y9u7On1CERExNAY7BvG4pJcBD1KMGj7Ssm2PLXUsaRSwADge6AWWSFpke0VLm8nAR4GjbW+QdEBZvx/w90ADMLC03HfDc3p2ERGx1QYbQXwYWASsAs6xvRqgvDbEsg76ngassr3a9hPApUD7pUvfCyzof+O3/WBZ/+fA9bbXl9uupxjFRETEMBlwBGH7FmByRf01wDUd9H0gsLal3EuxnlOrKQCSbgFGAZ8qL0ZUte+BHTxmREQMkTrPiFZFndvKoymS0LHAeOBmSa/ocF8kzQXmAhx00EHbEmtERLTp9HoQW6MXmNBSHg88UNHmSttP2l5D8a2pyR3ui+2Fthu2Gz09PUMafETEzq6T1Vw3G2VU1VVYAkyWNEnSGOBkimMara4Appd9jqWYcloNLAZOkLSvpH2BE8q6iIgYJp2MIG7rsG4TtjdSLNOxGLgH+Kbt5ZLml0uIU25bJ2kFcANwhu11ttdTrBi7pLzNL+siImKY6NlTHdo2FF85HUfx7aPZPHtcYG/gPNuHDEuEHWo0Gm42m90OIyJiRJG01HajattgU0VvAv6KYv5/Ac8miEeATwxphBERsd0Z7GuuFwAXSJpt+5vDGFNERGwHOjkGcYCkvQEkfUXSbZL+rOa4IiKiyzpJEHNtPyzpBIrppv8BfLbesCIiots6SRD9R7HfAFxge2mH+0VExAjWyRv9nZKuAd4CfE/SnlSc1RwRETuWTk54ezcwlWLhvcfKE9reU29YERHRbVscQdh+CvgjimMPALt3sl9ERIxsnSy18WWK5TDeUVb9DvhKnUFFRET3dTLF9BrbR0q6HcD2+nJtpYiI2IF1MlX0pKRdKA9MS9ofeLrWqCIiousGTBAtK7YuAL4N9Ej6B+BHwNnDEFtERHTRYFNMtwFH2r5I0lLg9RTrMb3V9t3DEl1ERHTNYAnimau62V4OLK8/nIiI2F4MliB6JP3dQBtt/0sN8URExHZisAQxCtiT6utDR0TEDm6wBPEr2/OHLZKIiNiuDPY114wcIiJ2YoMliG2+5oOkGZJWSlol6cyK7XMk9Um6o7yd2rLtbEl3l7e3bWssERHx3Ax2Rbn129KxpFEU51AcD/QCSyQtsr2irelltue17fsm4EjgcGA34CZJ37P98LbEFBERnatz0b1pFCvArrb9BHApMKvDfV8O3GR7o+3fAXcCM2qKMyIiKtSZIA4E1raUe8u6didKWibpckkTyro7gTdI2qNcXnw6MKF9R0lzJTUlNfv6+oY6/oiInVqdCaLqIHf7hYauAibaPhT4PvA1ANvXAdcAPwYuAX4CbNysM3uh7YbtRk9Pz1DGHhGx06szQfSy6af+8cADrQ1sr7P9eFk8l+LCRP3bPmP7cNvHUySbe2uMNSIi2tSZIJYAkyVNKpcHPxlY1NpA0riW4kzgnrJ+VLlqLJIOBQ4Frqsx1oiIaNPJ9SC2iu2NkuYBiynOyj7f9nJJ84Gm7UXAaZJmUkwfrQfmlLvvCtwsCeBh4B22N5tiioiI+shuPywwMjUaDTebzW6HERExokhaartRtS3Xlo6IiEpJEBERUSkJIiIiKiVBREREpSSIiIiolAQRERGVkiAiIqJSEkRERFRKgoiIiEpJEBERUSkJIiIiKiVBREREpSSIiIiolAQRERGVkiAiIqJSEkRERFRKgoiIiEq1JghJMyStlLRK0pkV2+dI6pN0R3k7tWXbZyUtl3SPpHNUXn80IiKGR23XpJY0ClgAHA/0AkskLbK9oq3pZbbnte37GuBo4NCy6kfA64Ab64o3IiI2VecIYhqwyvZq208AlwKzOtzXwPOAMcBuwK7Ar2uJMiIiKtWZIA4E1raUe8u6didKWibpckkTAGz/BLgB+FV5W2z7nvYdJc2V1JTU7OvrG/pnEBGxE6szQVQdM3Bb+Spgou1Dge8DXwOQ9BLgZcB4iqRynKTXbtaZvdB2w3ajp6dnSIOPiNjZ1ZkgeoEJLeXxwAOtDWyvs/14WTwXmFre/wvgVtuP2n4U+B7w6hpjjYiINnUmiCXAZEmTJI0BTgYWtTaQNK6lOBPon0b6BfA6SaMl7UpxgHqzKaaIiKhPbd9isr1R0jxgMTAKON/2cknzgabtRcBpkmYCG4H1wJxy98uB44C7KKalrrV9VV2xRkTE5mS3HxYYmRqNhpvNZrfDiIgYUSQttd2o2pYzqSMiolISREREVEqCiIiISkkQERFRKQkiIiIqJUFERESlJIiIiG209pG1zLl2DkdcdARzrp3D2kfWbnmnESAJIiJiG33ilk+w9NdL2eiNLP31Uj5xyye6HdKQSIKIiNhGdz5456DlkSoJIiJiGx12wGGDlkeqJIiIiG101tFnMfWFUxmt0Ux94VTOOvqsboc0JGpbrC8iYmcxYa8JXDjjwm6HMeQygoiIiEpJEBERUSkJIiIiKiVBREREpSSIiIioVGuCkDRD0kpJqySdWbF9jqQ+SXeUt1PL+uktdXdI+oOk/1pnrBERsanavuYqaRSwADge6AWWSFpke0Vb08tsz2utsH0DcHjZz37AKuC6umKNiIjN1TmCmAassr3a9hPApcCsrejnJOB7th8b0ugiImJQdSaIA4HWJQ17y7p2J0paJulySRMqtp8MXFL1AJLmSmpKavb19W17xBER8Yw6E4Qq6txWvgqYaPtQ4PvA1zbpQBoH/AmwuOoBbC+03bDd6OnpGYKQIyKiX50JohdoHRGMBx5obWB7ne3Hy+K5wNS2PmYD/277ydqijIiISnUmiCXAZEmTJI2hmCpa1NqgHCH0mwnc09bHKQwwvRQREfWq7VtMtjdKmkcxPTQKON/2cknzgabtRcBpkmYCG4H1wJz+/SVNpBiB3FRXjBERMTDZ7YcFRqZGo+Fms9ntMCIiRhRJS203qrblTOqIiKiUBBEREZWSICIiolISREREVEqCiIiISkkQERFRKQkiIiIqJUFERESlJIiI4bR+DVzwRpi/f/Fz/ZpuRxQxoCSIiOF05Qfg/lvg6Y3Fzys/0O2IIgaUBBExnNb+dPByxHYkCSJiOE141eDliO1IEkTEcJq1AA4+GnYZXfyctaDbEUUMqLblviOiwn6T4N3XdDuKiI5kBBEREZWSICIiolISREREVKo1QUiaIWmlpFWSzqzYPkdSn6Q7ytupLdsOknSdpHskrSgvQRoREcOktoPUkkYBC4DjgV5giaRFtle0Nb3M9ryKLi4CPmP7ekl7Ak/XFWtERGyuzhHENGCV7dW2nwAuBWZ1sqOklwOjbV8PYPtR24/VF2pERLSrM0EcCKxtKfeWde1OlLRM0uWSJpR1U4CHJH1H0u2SPleOSDYhaa6kpqRmX1/f0D+DiIidWJ3nQaiizm3lq4BLbD8u6X3A14DjyriOAY4AfgFcBswB/u8mndkLgYUA5bGM+4fyCWxnxgK/6XYQsdXy+o1cO/prd/BAG+pMEL3AhJbyeOCB1ga217UUzwXObtn3dturASRdAbyatgTR1lfPEMS83ZLUtN3odhyxdfL6jVw782tX5xTTEmCypEmSxgAnA4taG0ga11KcCdzTsu++kvrf9I8D2g9uR0REjWobQdjeKGkesBgYBZxve7mk+UDT9iLgNEkzgY3AeoppJGw/Jel04AeSBCylGGFERMQwkd1+WCC2R5LmlsdcYgTK6zdy7cyvXRJERERUylIbERFRKQkiIiIqJUFEbIGkD0naYyv2myPpRS3l88pVApD01nKdsRskNSSd8xz7vlHSTvnVy7q0vg6SdpP0/XKNuLd1O7ZuSYIYRpImSvrLDtpdUp5d/rfDEVenOo1/B/QhoDJBVJ3h32IO8EyCsH1qy1pk7wHeb3u67abt04Yq2Ng6ba/DEcCutg+3fVkn+2/hb2FESoIYXhOBQd9gJf0X4DW2D7X9xbZt3b4C4ES2EP9IJ+n5kr4r6U5Jd0v6e4o3+Rsk3VC2eVTSfEk/BY6S9ElJS8r2C1U4CWgA3yg/he7e/6lf0ieBPwW+Ui4jc6ykq1se//yyv9slzSrrd5d0afnB4TJg9278fkaS8gPN3S3l0yV9qnwdzpZ0m6SfSzqm3H6spKslHQB8HTi8fO1eLOnPytfjrvL12a3c577y9f8R8Nay7y9K+mE5QnxluWTQvZI+3ZVfxLawndsAN4o3xP8AzgPuBr4BvB64BbiXYkHC/YArgGXArcCh5b6vA+4ob7cDe5Xbf1vW/e0Aj7kM+H3Z5hjgRuAfgZuADwM9wLcpTiZcAhxd7rc/cF35WF8F7qdYImAicHdL/6cDnyrvvxi4luI8k5uBQ8r6C4FzgB8Dq4GTyvotxj/Sb8CJwLkt5RcA9wFjW+oMzG4p79dy/9+At5T3bwQaLdueKbfdPxa4urz/j8A7yvv7AD8Hng/8HcW5RACHUpw71NjW57sj3wb62y9/918o694IfL/idWi9/zyKdeWmlOWLgA+V9+8DPtL2Gp9d3v8bitUjxgG7UawQsX+3fy/P5ZYRxJa9BPjfFP+Uh1B8gv5Tij+2/wn8A8WyIIeW5YvK/U4HPmD7cIo3+t8DZwI3uxi2bjI6aDET+M+yzc1l3T62X2f7C2UsX7T9Soo3s/PKNn8P/Mj2ERRnrB/UwXNbCHzQ9tQy3n9t2TaufJ5vBv65rOsk/pHuLuD15SfMY2z/tqLNUxRJut90ST+VdBfFWf9/vA2PfwJwpqQ7KN5snkfxWr6W4lMttpdRfJCIrfed8udSikQymJcCa2z/vCx/jeL16Nc+BdW/YsRdwHLbv7L9OMWHrQmMIN2eshgJ1ti+C0DScuAHtl2+GUykWOjqRADb/0/S/pJeQDHK+BdJ3wC+Y7u3OCl8q7T+Ab4eeHlLX3tL2oviD/a/lXF8V9KGwTpUcY2N1wDfaulrt5YmV9h+Glgh6YVbG/hIY/vnkqZSfLL8J0nXVTT7g+2nACQ9jyKxNmyvlfQpijf1rSXgRNsrN6ksXqOctPTcbGTTafTW1+Xx8udTbPl9cEv/uL9rK/f3/XTL/f7yiHrPzQhiy9pf4NYXfzQDrFpr+5+BUynmim+VdMg2xND6B7gLcFT5Kf5w2wfafqT/cSv2HeifZBfgoZZ+Drf9spZ2rc97qzPbSFN+6+gx218HPg8cCTxCMUVYpf/3+Zsy6Z7Usm2w/QayGPhgucQMko4o638IvL2sewXFiDYG92vggPJD224Uo+Gt8R/AREkvKcv/nWLKd4eXBLHtWv9xjwV+Y/thSS+2fZfts4EmxfTU1rxhtLsOeOYKfJIOr4jjDcC+ZX3lP4nth4E1kt5a7iNJh23hsYci/u3dnwC3lVM8HwM+TTEV973+g9StbD9EsU7YXRTHopa0bL6Q4kD0HZI6Pah8FrArsKw8wHpWWf9/gD0lLQM+Atz2XJ/Yzsb2k8B84KfA1RRv9FvTzx+Ad1OMtu+i+HD4laGKc3uWpTYGoeI62FfbfkVZvrAsX96/jWJq5wJgEvAYMNf2MklfAqZTDGFXUHzl8WmKg8JjgQur5vErHvNG4HTbzbI8luJSri+jGMH80Pb7JO0PXFL2fRPFdNNU27+RdBpwGrAG+CVwn+1PSZpE8cYzjuJN6VLb81ufZ/mYj9reU9KuW4o/InYcSRA7KEn3UcyL78gXOomIGmWKKSIiKmUE0SWS/pxnr6DXb43tv+hGPBER7ZIgIiKiUqaYIiKiUhJERERUSoKIqCDpY5KWl4vj3SHpVRqiZb8jRookiIg2ko6iOKHwyHKNrddTLNY2JMt+R4wUSRARmxtHcUb84wDluSQnMXTLfk+VdJOkpZIWSxpX9vfKcsTyExXLgN9d1t/ccsY8km6RlKU2onZJEBGbuw6YoOJaAf8q6XW2z6FYunm67ellu+dTLCf9Kts/Ar5s+5XlWfC7A28uz0ZvAm8vV/bdCHyJYgn1qcD5wGfK/i4A3mf7KIoz8PudRzEKQdIUYLdyRdeIWiVBRLSx/SgwFZgL9AGXSZpT0XRrlv1+KfAK4PpyvaePA+Ml7QPsZfvHZbuLW/b5FvDmcqmTv6JY4ymidiNq6dmI4VIu530jcGP5hv+uimZbs+y3KK4RcNQmldK+FW37Y3lM0vXALGA2xZRVRO0ygohoI+mlkia3VB1OcYW+oVj2eyXQUx4IR9Kukv7Y9gbgEUmvLtud3Nb/eRRX+Vtie/3WPK+I5yojiIjN7Ql8qZz22QisophuOoVi2e9ftRyHAIplvyX1L/t9H9XLfv8eOIoieZxTXlhqNPC/gOXAe4BzJf2OYvTy25b+l0p6mOI4RcSwyFIbEdsJSXuWxz+QdCYwzvbflOUXUSSNQ8or/UXULlNMEduPN5Vfhb2b4jrmnwaQ9E6Ki958LMkhhlNGEBERUSkjiIiIqJQEERERlZIgIiKiUhJERERUSoKIiIhK/x8uoDdie+EbqgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = sns.stripplot(strategies, test_scores); \n",
    "ax.set(xlabel ='Strategy', ylabel ='Test Score') \n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checking the performance of `RandomForestClassifier` on the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.776595744680851"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "ans=RandomForestClassifier()\n",
    "ans.fit(X_train,y_train)\n",
    "prediction=ans.predict(X_test)\n",
    "accuracy_score(y_test,prediction)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On comparing the scores of the KNN classifier with the dummy classifier, we come to the conclusion that the KNN classifier is, in fact, a good classifier for the given data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imbalanced Class and `Dummy Classifier`\n",
    "\n",
    "A major motivation for Dummy Classifier is F-score, when the positive class is in minority (i.e. imbalanced classes). This classifier is used for sanity test of actual classifier. Actually, dummy classifier completely ignores the input data. In case of 'most frequent' method, it checks the occurrence of most frequent label."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 178\n",
      "1 182\n",
      "2 177\n",
      "3 183\n",
      "4 181\n",
      "5 182\n",
      "6 181\n",
      "7 179\n",
      "8 174\n",
      "9 180\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_digits\n",
    "\n",
    "dataset = load_digits()\n",
    "X, y = dataset.data, dataset.target\n",
    "\n",
    "for class_name, class_count in zip(dataset.target_names, np.bincount(dataset.target)):\n",
    "    print(class_name,class_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original labels:\t [1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9]\n",
      "New binary labels:\t [1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0]\n"
     ]
    }
   ],
   "source": [
    "y_imbalanced = y.copy()\n",
    "y_imbalanced[y_imbalanced != 1] = 0\n",
    "\n",
    "print('Original labels:\\t', y[1:20])\n",
    "print('New binary labels:\\t', y_imbalanced[1:20])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1615,  182], dtype=int64)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.bincount(y_imbalanced)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can observe that in the above data array one class is more frequent than other which shows it is an imbalanced class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5466666666666666"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train1, X_test1, y_train1, y_test1 = train_test_split(X, y_imbalanced, random_state=0)\n",
    "\n",
    "# Accuracy of Support Vector Machine classifier\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "gnb = GaussianNB()\n",
    "y_pred = gnb.fit(X_train1, y_train1)\n",
    "gnb.score(X_test1, y_test1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here on using Naive Bayes Classifier we get a score of 0.55 , We know this is not a good score and we can use other classifiers and fit the model and check their score. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9088888888888889"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "clf = RandomForestClassifier(max_depth=2, random_state=0).fit(X_train1, y_train1)\n",
    "clf.score(X_test1,y_test1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On Using RandomForestClassifier we get a score of 0.908 which is a great score and also much better than what Naive Bayes Classifier performed . "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using dummy classifier as baseline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9044444444444445"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.dummy import DummyClassifier\n",
    "dummy_majority = DummyClassifier(strategy = 'most_frequent').fit(X_train1, y_train1)\n",
    "y_dummy_predictions = dummy_majority.predict(X_test)\n",
    "dummy_majority.score(X_test1, y_test1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe that the RandomForest classsifier score is not much compared to dummy classifier which also has a score of more than .90 . Which shows that RandomForest is not a right fit for the model despite the good score.\n",
    "This makes us realise that we need a better model which scores better ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9955555555555555"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.svm import SVC\n",
    "svm = SVC(kernel='rbf', C=1).fit(X_train1, y_train1)\n",
    "svm.score(X_test1, y_test1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On using SVM classifier using RBF kernel for the model,gives a whoping score of 0.99 which is a good score as well as it  performce better than dummy classifier which is our baseline. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Thus, Dummy Classifier works as a baseline and gives an idea of the performance of the model on dataset*\n"
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}