Predicting_Hand_Written_Digits.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Callenges with image classification\n",
    "# Highly dimensional, meaning each pixel each a feature and seperate column, feature x feature\n",
    "# Computation power is limited to consider high pixelation, \n",
    "## Means less details are considered that may be pertinent to an accurate classifier\n",
    "# Third, the features in an image don't have an obvious linear or nonlinear relationship that can be learned with a model like linear or logistic regression\n",
    "# Deep Learning is effective because for the ability to learn hierachical representations. At a high level and effective deep learning model learns intermediate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_digits\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.model_selection import KFold\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       0\n",
       "1       1\n",
       "2       2\n",
       "3       3\n",
       "4       4\n",
       "       ..\n",
       "1792    9\n",
       "1793    0\n",
       "1794    8\n",
       "1795    9\n",
       "1796    8\n",
       "Length: 1797, dtype: int64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "digits = load_digits()\n",
    "labels = pd.Series(digits['target'])\n",
    "data = pd.DataFrame(digits['data'])\n",
    "first_image = data.iloc[0]\n",
    "second_image = data.iloc[1]\n",
    "\n",
    "# np_image = first_image.values\n",
    "# np_image = np_image.reshape(8,8)\n",
    "# np2_image = second_image.values\n",
    "# np2_image = second_image.reshape(8,8)\n",
    "# plt.imshow(np_image, cmap='gray_r')\n",
    "# # plt.imshow(np_image2, cmap='gray_r')\n",
    "# plt.show()\n",
    "labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f04b15e9be0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f, axarr = plt.subplots(2, 4)\n",
    "\n",
    "axarr[0,0].imshow(data.iloc[0].values.reshape(8,8), cmap='gray_r')\n",
    "axarr[0,1].imshow(data.iloc[99].values.reshape(8,8), cmap='gray_r')\n",
    "axarr[0,2].imshow(data.iloc[199].values.reshape(8,8), cmap='gray_r')\n",
    "axarr[0,3].imshow(data.iloc[299].values.reshape(8,8), cmap='gray_r')\n",
    "\n",
    "axarr[1,0].imshow(data.iloc[999].values.reshape(8,8), cmap='gray_r')\n",
    "axarr[1,1].imshow(data.iloc[1099].values.reshape(8,8), cmap='gray_r')\n",
    "axarr[1,2].imshow(data.iloc[1199].values.reshape(8,8), cmap='gray_r')\n",
    "axarr[1,3].imshow(data.iloc[1299].values.reshape(8,8), cmap='gray_r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/model_selection/_split.py:293: FutureWarning:\n",
      "\n",
      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.9677233358079684"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 50% Train / test validation\n",
    "def train_knn(nneighbors, train_features, train_labels):\n",
    "    knn = KNeighborsClassifier(n_neighbors = nneighbors)\n",
    "    knn.fit(train_features, train_labels)\n",
    "    return knn\n",
    "\n",
    "def test(model, test_features, test_labels):\n",
    "    predictions = model.predict(test_features)\n",
    "    train_test_df = pd.DataFrame()\n",
    "    train_test_df['correct_label'] = test_labels\n",
    "    train_test_df['predicted_label'] = predictions\n",
    "    overall_accuracy = sum(train_test_df[\"predicted_label\"] == train_test_df[\"correct_label\"])/len(train_test_df)    \n",
    "    return overall_accuracy\n",
    "\n",
    "def cross_validate(k):\n",
    "    fold_accuracies = []\n",
    "    kf = KFold(n_splits = 4, random_state=2)\n",
    "    for train_index, test_index in kf.split(data):\n",
    "        train_features, test_features = data.loc[train_index], data.loc[test_index]\n",
    "        train_labels, test_labels = labels.loc[train_index], labels.loc[test_index]\n",
    "        model = train_knn(k, train_features, train_labels)\n",
    "        overall_accuracy = test(model, test_features, test_labels)\n",
    "        fold_accuracies.append(overall_accuracy)\n",
    "    return fold_accuracies\n",
    "        \n",
    "knn_one_accuracies = cross_validate(1)\n",
    "np.mean(knn_one_accuracies)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "\n",
    "# 50% Train / test validation\n",
    "def train_nn(neuron_arch, train_features, train_labels):\n",
    "    mlp = MLPClassifier(hidden_layer_sizes=neuron_arch)\n",
    "    mlp.fit(train_features, train_labels)\n",
    "    return mlp\n",
    "\n",
    "def test(model, test_features, test_labels):\n",
    "    predictions = model.predict(test_features)\n",
    "    train_test_df = pd.DataFrame()\n",
    "    train_test_df['correct_label'] = test_labels\n",
    "    train_test_df['predicted_label'] = predictions\n",
    "    overall_accuracy = sum(train_test_df[\"predicted_label\"] == train_test_df[\"correct_label\"])/len(train_test_df)    \n",
    "    return overall_accuracy\n",
    "\n",
    "def cross_validate(neuron_arch):\n",
    "    fold_accuracies = []\n",
    "    kf = KFold(n_splits = 4, random_state=2)\n",
    "    for train_index, test_index in kf.split(data):\n",
    "        train_features, test_features = data.loc[train_index], data.loc[test_index]\n",
    "        train_labels, test_labels = labels.loc[train_index], labels.loc[test_index]\n",
    "       \n",
    "        model = train_nn(neuron_arch, train_features, train_labels)\n",
    "        overall_accuracy = test(model, test_features, test_labels)\n",
    "        fold_accuracies.append(overall_accuracy)\n",
    "    return fold_accuracies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/model_selection/_split.py:293: FutureWarning:\n",
      "\n",
      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/model_selection/_split.py:293: FutureWarning:\n",
      "\n",
      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/model_selection/_split.py:293: FutureWarning:\n",
      "\n",
      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/model_selection/_split.py:293: FutureWarning:\n",
      "\n",
      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/model_selection/_split.py:293: FutureWarning:\n",
      "\n",
      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/model_selection/_split.py:293: FutureWarning:\n",
      "\n",
      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f04ad481460>]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "nn_one_neurons = [\n",
    "    (8,),\n",
    "    (16,),\n",
    "    (32,),\n",
    "    (64,),\n",
    "    (128,),\n",
    "    (256,)\n",
    "]\n",
    "nn_one_accuracies = []\n",
    "\n",
    "for n in nn_one_neurons:\n",
    "    nn_accuracies = cross_validate(n)\n",
    "    nn_mean_accuracy = np.mean(nn_accuracies)\n",
    "    nn_one_accuracies.append(nn_mean_accuracy)\n",
    "\n",
    "plt.figure(figsize=(8,4))\n",
    "plt.title(\"Mean Accuracy vs. Neurons In Single Hidden Layer\")\n",
    "\n",
    "x = [i[0] for i in nn_one_neurons]\n",
    "plt.plot(x, nn_one_accuracies)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.8358042563721853,\n",
       " 0.9243095768374165,\n",
       " 0.9293281365998516,\n",
       " 0.9382306359811927,\n",
       " 0.9404553328384063,\n",
       " 0.9488059886166791]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nn_one_accuracies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/model_selection/_split.py:293: FutureWarning:\n",
      "\n",
      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/model_selection/_split.py:293: FutureWarning:\n",
      "\n",
      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/model_selection/_split.py:293: FutureWarning:\n",
      "\n",
      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning:\n",
      "\n",
      "Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/model_selection/_split.py:293: FutureWarning:\n",
      "\n",
      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/model_selection/_split.py:293: FutureWarning:\n",
      "\n",
      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "\n",
      "/dataquest/system/env/python3/lib/python3.8/site-packages/sklearn/model_selection/_split.py:293: FutureWarning:\n",
      "\n",
      "Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f04ad5ee190>]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "nn_one_neurons = [\n",
    "    (10,),\n",
    "    (16,),\n",
    "    (32,),\n",
    "    (64,),\n",
    "    (128,),\n",
    "    (256,)\n",
    "]\n",
    "nn_one_accuracies = []\n",
    "\n",
    "for n in nn_one_neurons:\n",
    "    nn_accuracies = cross_validate(n)\n",
    "    nn_mean_accuracy = np.mean(nn_accuracies)\n",
    "    nn_one_accuracies.append(nn_mean_accuracy)\n",
    "\n",
    "plt.figure(figsize=(8,4))\n",
    "plt.title(\"Mean Accuracy vs. Neurons In Single Hidden Layer\")\n",
    "\n",
    "x = [i[0] for i in nn_one_neurons]\n",
    "plt.plot(x, nn_one_accuracies)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}