diff --git a/Homework/Gaurav_Khanna_p1.ipynb b/Homework/Gaurav_Khanna_p1.ipynb
new file mode 100644
index 0000000..05be80b
--- /dev/null
+++ b/Homework/Gaurav_Khanna_p1.ipynb
@@ -0,0 +1,1544 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Project 1: Digit Classification with KNN and Naive Bayes"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In this project, you'll implement your own image recognition system for classifying digits. Read through the code and the instructions carefully and add your own code where indicated. Each problem can be addressed succinctly with the included packages -- please don't add any more. Grading will be based on writing clean, commented code, along with a few short answers.\n",
+ "\n",
+ "As always, you're welcome to work on the project in groups and discuss ideas on the course wall, but please prepare your own write-up (with your own code). \n",
+ "\n",
+ "If you're interested, check out these links related to digit recognition:\n",
+ "\n",
+ "Yann Lecun's MNIST benchmarks: http://yann.lecun.com/exdb/mnist/\n",
+ "\n",
+ "Stanford Streetview research and data: http://ufldl.stanford.edu/housenumbers/"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 199,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# This tells matplotlib not to try opening a new window for each plot.\n",
+ "%matplotlib inline\n",
+ "\n",
+ "# Import a bunch of libraries.\n",
+ "import time\n",
+ "import numpy as np\n",
+ "import math\n",
+ "import matplotlib.pyplot as plt\n",
+ "import sklearn.preprocessing\n",
+ "from matplotlib.ticker import MultipleLocator\n",
+ "from sklearn.pipeline import Pipeline\n",
+ "from sklearn.datasets import fetch_mldata\n",
+ "from sklearn.neighbors import KNeighborsClassifier\n",
+ "from sklearn.metrics import confusion_matrix\n",
+ "from sklearn.linear_model import LinearRegression\n",
+ "from sklearn.naive_bayes import BernoulliNB\n",
+ "from sklearn.naive_bayes import MultinomialNB\n",
+ "from sklearn.naive_bayes import GaussianNB\n",
+ "#from sklearn.grid_search import GridSearchCV\n",
+ "from sklearn.model_selection import GridSearchCV\n",
+ "from sklearn.metrics import classification_report\n",
+ "\n",
+ "# Set the randomizer seed so results are the same each time.\n",
+ "np.random.seed(0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Load the data. Notice that we are splitting the data into training, development, and test. We also have a small subset of the training data called mini_train_data and mini_train_labels that you should use in all the experiments below, unless otherwise noted."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "data shape: (70000, 784)\n",
+ "label shape: (70000,)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Load the digit data either from mldata.org, or once downloaded to data_home, from disk. The data is about 53MB so this cell\n",
+ "# should take a while the first time your run it.\n",
+ "mnist = fetch_mldata('MNIST original', data_home='~/datasets/mnist')\n",
+ "X, Y = mnist.data, mnist.target\n",
+ "\n",
+ "# Rescale grayscale values to [0,1].\n",
+ "X = X / 255.0\n",
+ "\n",
+ "# Shuffle the input: create a random permutation of the integers between 0 and the number of data points and apply this\n",
+ "# permutation to X and Y.\n",
+ "# NOTE: Each time you run this cell, you'll re-shuffle the data, resulting in a different ordering.\n",
+ "shuffle = np.random.permutation(np.arange(X.shape[0]))\n",
+ "X, Y = X[shuffle], Y[shuffle]\n",
+ "\n",
+ "print ('data shape: ', X.shape)\n",
+ "print ('label shape:', Y.shape)\n",
+ "\n",
+ "# Set some variables to hold test, dev, and training data.\n",
+ "test_data, test_labels = X[61000:], Y[61000:]\n",
+ "dev_data, dev_labels = X[60000:61000], Y[60000:61000]\n",
+ "train_data, train_labels = X[:60000], Y[:60000]\n",
+ "mini_train_data, mini_train_labels = X[:1000], Y[:1000]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "(1) Create a 10x10 grid to visualize 10 examples of each digit. Python hints:\n",
+ "\n",
+ "- plt.rc() for setting the colormap, for example to black and white\n",
+ "- plt.subplot() for creating subplots\n",
+ "- plt.imshow() for rendering a matrix\n",
+ "- np.array.reshape() for reshaping a 1D feature vector into a 2D matrix (for rendering)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 101,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def P1(num_examples=10):\n",
+ "\n",
+ "### STUDENT START ###\n",
+ "\n",
+ "# Strategy: Walk through Y (mnist.target)\n",
+ "# exctract the digit, extract the corresponding feature list from X (mnist.data)\n",
+ "# put the extracted array of features into the 10*10 grid for display\n",
+ "\n",
+ "# This array keeps track of the number of instances of a digit we have found while walking the target array #\n",
+ " digCount = [0 for i in range(10)]\n",
+ " \n",
+ "# We'll need a function to find if we got 10 instances of all digits\n",
+ "# The Function returns False if we found 10 instances of all digits\n",
+ "\n",
+ " def isSpace(ar, instance = 10):\n",
+ " x = 0\n",
+ " for i in range(len(ar)):\n",
+ " x += ar[i]\n",
+ " if x < (instance)**2:\n",
+ " return True\n",
+ " else:\n",
+ " return False\n",
+ " \n",
+ "# We'll need a function to find if we got 10 instances of a digit\n",
+ "# The Function returns False if we found 10 instances of a digits\n",
+ "\n",
+ " def isSpaceDigit(ar, d = 0, instance = 10):\n",
+ " if ar[d] < instance:\n",
+ " return True\n",
+ " else: \n",
+ " return False\n",
+ " \n",
+ "# print(digClount)\n",
+ "\n",
+ "# Now we are walking the target array and creating plots of 10 instances of each digit\n",
+ " \n",
+ " for i in range(len(Y)):\n",
+ " Xp = X[i].reshape(28,28)\n",
+ " \n",
+ " # Is there space for an instance of the digit Y[i]? \n",
+ " if isSpaceDigit(digCount, int(Y[i]), num_examples):\n",
+ " # Yes, there is space, lets plot this digit\n",
+ " # We'll put this digit in the \"digit\" row and collumn digCount\n",
+ " plt.subplot(num_examples, num_examples, (Y[i] * num_examples) + 1 + digCount[int(Y[i])])\n",
+ " plt.axis(\"off\")\n",
+ " plt.imshow(Xp, aspect = \"auto\", cmap = plt.cm.gray_r, interpolation = \"nearest\")\n",
+ " digCount[int(Y[i])] +=1\n",
+ " else:\n",
+ " # Have we filled up all of the 10 * 10 array? \n",
+ " if not (isSpace(digCount, num_examples)):\n",
+ " break\n",
+ "plt.show()\n",
+ "\n",
+ " \n",
+ "### STUDENT END ###\n",
+ "\n",
+ "P1(10)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "(2) Evaluate a K-Nearest-Neighbors model with k = [1,3,5,7,9] using the mini training set. Report accuracy on the dev set. For k=1, show precision, recall, and F1 for each label. Which is the most difficult digit?\n",
+ "\n",
+ "- KNeighborsClassifier() for fitting and predicting\n",
+ "- classification_report() for producing precision, recall, F1 results"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 175,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The Mean Square Error for K = 1 on the dev data set is 2.119\n",
+ "The accuracy is 88.8 %\n",
+ "\n",
+ "Classification Report\n",
+ "\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " 0.0 0.91 0.98 0.94 99\n",
+ " 1.0 0.89 1.00 0.94 105\n",
+ " 2.0 0.99 0.79 0.88 102\n",
+ " 3.0 0.77 0.87 0.82 86\n",
+ " 4.0 0.89 0.82 0.85 104\n",
+ " 5.0 0.93 0.84 0.88 91\n",
+ " 6.0 0.94 0.96 0.95 98\n",
+ " 7.0 0.89 0.92 0.90 113\n",
+ " 8.0 0.94 0.88 0.91 96\n",
+ " 9.0 0.78 0.82 0.80 106\n",
+ "\n",
+ "avg / total 0.89 0.89 0.89 1000\n",
+ "\n",
+ "\n",
+ "The Mean Square Error for K = 3 on the dev data set is 2.128\n",
+ "The accuracy is 87.8 %\n",
+ "\n",
+ "The Mean Square Error for K = 5 on the dev data set is 2.469\n",
+ "The accuracy is 86.9 %\n",
+ "\n",
+ "The Mean Square Error for K = 7 on the dev data set is 2.357\n",
+ "The accuracy is 86.5 %\n",
+ "\n",
+ "The Mean Square Error for K = 9 on the dev data set is 2.435\n",
+ "The accuracy is 86.3 %\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "def P2(k_values):\n",
+ "\n",
+ "### STUDENT START ###\n",
+ "\n",
+ "# Walk through the list of K_values\n",
+ " for i in k_values:\n",
+ " \n",
+ " # Create the knn model.\n",
+ " knnModel = KNeighborsClassifier(i)\n",
+ " \n",
+ " # Fit the model on mini training set\n",
+ " knnModel.fit(mini_train_data, mini_train_labels)\n",
+ "\n",
+ " # Try on the development set\n",
+ " predictions = knnModel.predict(dev_data)\n",
+ " \n",
+ " # 2 metrics to get an idea of accuracy: Mean Squared Error and model score\n",
+ " \n",
+ " # Mean Squared error of the predictions\n",
+ " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n",
+ " sc = knnModel.score(dev_data, dev_labels)\n",
+ " \n",
+ " # Print the MSE and accuracy for a value of K\n",
+ " print(\"The Mean Square Error for K = \", i, \" on the dev data set is \", meanse)\n",
+ " print(\"The accuracy is\", (sc*100), \"%\")\n",
+ " print()\n",
+ " \n",
+ " # if K = 1, also print the precision, recall and F1 report\n",
+ " if i == 1:\n",
+ " print(\"Classification Report\")\n",
+ " print()\n",
+ " print(classification_report(dev_labels, predictions))\n",
+ " print()\n",
+ " \n",
+ "### STUDENT END ###\n",
+ "\n",
+ "k_values = [1, 3, 5, 7, 9]\n",
+ "P2(k_values)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "ANSWER: \"3\" (precision of .77) seems to be the most difficult digit to predict"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "(3) Using k=1, report dev set accuracy for the training set sizes below. Also, measure the amount of time needed for prediction with each training size.\n",
+ "\n",
+ "- time.time() gives a wall clock value you can use for timing operations"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 176,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "The Dev set accuracy for training data size: 100 is 72.0 %\n",
+ "Time taken for the predictions is 0.12468504905700684\n",
+ "\n",
+ "\n",
+ "The Dev set accuracy for training data size: 200 is 78.6 %\n",
+ "Time taken for the predictions is 0.23468804359436035\n",
+ "\n",
+ "\n",
+ "The Dev set accuracy for training data size: 400 is 84.1 %\n",
+ "Time taken for the predictions is 0.4730370044708252\n",
+ "\n",
+ "\n",
+ "The Dev set accuracy for training data size: 800 is 88.4 %\n",
+ "Time taken for the predictions is 0.951606035232544\n",
+ "\n",
+ "\n",
+ "The Dev set accuracy for training data size: 1600 is 90.2 %\n",
+ "Time taken for the predictions is 1.9812893867492676\n",
+ "\n",
+ "\n",
+ "The Dev set accuracy for training data size: 3200 is 92.6 %\n",
+ "Time taken for the predictions is 3.9774398803710938\n",
+ "\n",
+ "\n",
+ "The Dev set accuracy for training data size: 6400 is 93.7 %\n",
+ "Time taken for the predictions is 7.833939790725708\n",
+ "\n",
+ "\n",
+ "The Dev set accuracy for training data size: 12800 is 95.9 %\n",
+ "Time taken for the predictions is 15.428621053695679\n",
+ "\n",
+ "\n",
+ "The Dev set accuracy for training data size: 25000 is 97.0 %\n",
+ "Time taken for the predictions is 30.57994508743286\n",
+ "\n",
+ "\n",
+ "Accuracy Matrix\n",
+ "[0.71999999999999997, 0.78600000000000003, 0.84099999999999997, 0.88400000000000001, 0.90200000000000002, 0.92600000000000005, 0.93700000000000006, 0.95899999999999996, 0.96999999999999997]\n"
+ ]
+ }
+ ],
+ "source": [
+ "def P3(train_sizes, accuracies):\n",
+ "\n",
+ "### STUDENT START ###\n",
+ "\n",
+ " for tr in train_sizes:\n",
+ " \n",
+ " # Fit the model\n",
+ " knnModel = KNeighborsClassifier(1)\n",
+ " knnModel.fit(train_data[:tr], train_labels[:tr])\n",
+ "\n",
+ " # Try on the development set and time the operation\n",
+ " sTime = time.time()\n",
+ " predictions = knnModel.predict(dev_data)\n",
+ " eTime = time.time()\n",
+ " \n",
+ " # Accuracy\n",
+ " sc = knnModel.score(dev_data, dev_labels)\n",
+ " accuracies.append(sc)\n",
+ " \n",
+ " # Print the MSE and accuracy for a value of K\n",
+ " print()\n",
+ " print(\"The Dev set accuracy for training data size:\", tr, \"is\", (sc*100), \"%\")\n",
+ " print(\"Time taken for the predictions is\", eTime - sTime)\n",
+ " print()\n",
+ " \n",
+ "### STUDENT END ###\n",
+ "\n",
+ "train_sizes = [100, 200, 400, 800, 1600, 3200, 6400, 12800, 25000]\n",
+ "accuracies = []\n",
+ "P3(train_sizes, accuracies)\n",
+ "print()\n",
+ "print(\"Accuracy Matrix\")\n",
+ "print(accuracies)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "(4) Fit a regression model that predicts accuracy from training size. What does it predict for n=60000? What's wrong with using regression here? Can you apply a transformation that makes the predictions more reasonable?\n",
+ "\n",
+ "- Remember that the sklearn fit() functions take an input matrix X and output vector Y. So each input example in X is a vector, even if it contains only a single value."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 205,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Train Sizes Array \n",
+ "\n",
+ "[100, 200, 400, 800, 1600, 3200, 6400, 12800, 25000]\n",
+ "\n",
+ "Modified Train Sizes Array \n",
+ "\n",
+ "[[ 100]\n",
+ " [ 200]\n",
+ " [ 400]\n",
+ " [ 800]\n",
+ " [ 1600]\n",
+ " [ 3200]\n",
+ " [ 6400]\n",
+ " [12800]\n",
+ " [25000]]\n",
+ "\n",
+ "The Model predicting accuracy from Training data size \n",
+ "\n",
+ "y = 6.6652713854943685e-06 * x + 0.8431559772258371\n",
+ "\n",
+ "Accuracy with training data size of 60K \n",
+ " [ 124.30722604]\n",
+ "\n",
+ "Accuracy with training data size of 60K with normalized input \n",
+ " [ 100.]\n"
+ ]
+ }
+ ],
+ "source": [
+ "def P4():\n",
+ "\n",
+ "### STUDENT START ###\n",
+ "\n",
+ " # Starting a linear regression #\n",
+ " reg = LinearRegression()\n",
+ " \n",
+ " print(\"Train Sizes Array \\n\")\n",
+ " print(train_sizes)\n",
+ " print()\n",
+ " \n",
+ " # Reshaping train_sizes to a matrix #\n",
+ " train_sizes_re = np.array(train_sizes).reshape(-1,1)\n",
+ " print(\"Modified Train Sizes Array \\n\")\n",
+ " print(train_sizes_re)\n",
+ " print()\n",
+ " \n",
+ " # Fitting the model #\n",
+ " print(\"The Model predicting accuracy from Training data size \\n\")\n",
+ " reg.fit(train_sizes_re, accuracies)\n",
+ " print('y = {0} * x + {1}'.format(reg.coef_[0], reg.intercept_))\n",
+ " print()\n",
+ " \n",
+ " # Finding the prediction for training data size of 60000\n",
+ " print(\"Accuracy with training data size of 60K \\n\", reg.predict(60000) * 100)\n",
+ " \n",
+ " # Scaling accuracies to get more reasonable predictions\n",
+ " accuracies_re = np.copy(np.array(accuracies))\n",
+ " mx = np.max(accuracies_re)\n",
+ " mi = np.min(accuracies_re)\n",
+ " \n",
+ " # print(accuracies_re)\n",
+ " \n",
+ " for i in range(len(accuracies_re)):\n",
+ " accuracies_re[i] = (accuracies_re[i]-mi)/(mx-mi)\n",
+ " \n",
+ " # print(accuracies_re)\n",
+ " reg.fit(train_sizes_re, accuracies_re)\n",
+ " \n",
+ " pred = reg.predict(60000)\n",
+ " \n",
+ " # Normalizing the prediction like we did for accuracies\n",
+ " # print(pred)\n",
+ " print()\n",
+ " print(\"Accuracy with training data size of 60K with normalized input \\n\", (pred-mi)/(pred-mi) * 100)\n",
+ " \n",
+ "### STUDENT END ###\n",
+ "\n",
+ "P4()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "ANSWER: The accuracy prediction (form the linear regression without any transforms) is 1.243 or 124. This is obviously not what we expected (We're expecting the accuracy to stay within the 100% bounds, i.e. the predictions to be in the range [0, 1])\n",
+ "\n",
+ "Can we do a transform to make the predictions more reasonable? Yes, I think we can normalize \"accuracies\" used for training to get more reasonable predicdtions. The predication before normalization is 124%. After its close to 100% as that's the max of the accuracies"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Fit a 1-NN and output a confusion matrix for the dev data. Use the confusion matrix to identify the most confused pair of digits, and display a few example mistakes.\n",
+ "\n",
+ "- confusion_matrix() produces a confusion matrix"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 207,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Confusion matrix:\n",
+ "\n",
+ "[[ 97 0 0 0 0 0 2 0 0 0]\n",
+ " [ 0 105 0 0 0 0 0 0 0 0]\n",
+ " [ 4 4 81 4 0 0 0 4 3 2]\n",
+ " [ 1 0 0 75 0 3 0 3 1 3]\n",
+ " [ 0 2 0 0 85 0 3 0 0 14]\n",
+ " [ 2 0 0 9 0 76 0 1 1 2]\n",
+ " [ 1 1 1 0 1 0 94 0 0 0]\n",
+ " [ 1 4 0 1 1 0 0 104 0 2]\n",
+ " [ 0 2 0 5 0 2 1 0 84 2]\n",
+ " [ 1 0 0 3 9 1 0 5 0 87]]\n",
+ "\n",
+ "\n",
+ "The most confused digits with the predicted digit as title\n",
+ "\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def P5():\n",
+ "\n",
+ "### STUDENT START ###\n",
+ "\n",
+ " # Starting a 1-NN model #\n",
+ " knnModel = KNeighborsClassifier(1)\n",
+ " \n",
+ " # Fitting with training data\n",
+ " knnModel.fit(mini_train_data, mini_train_labels)\n",
+ "\n",
+ " # Try on the development set and time the operation\n",
+ " predictions = knnModel.predict(dev_data)\n",
+ " \n",
+ " # Confusion matrix\n",
+ " dig = [i for i in range(10)]\n",
+ " sc = confusion_matrix(dev_labels, predictions, labels = dig)\n",
+ " # Printing the matrix natively\n",
+ " print(\"Confusion matrix:\\n\\n%s\" % sc)\n",
+ " print()\n",
+ " \n",
+ " # 4 & 9 seem to be the most confused digits #\n",
+ " \n",
+ " # printing 8 examples of 4 & 9 labeled as each other #\n",
+ " count = 0\n",
+ " print()\n",
+ " print(\"The most confused digits with the predicted digit as title\")\n",
+ " print()\n",
+ " \n",
+ " # We'll walk through the all the labeled in dev_data #\n",
+ " for i in range(len(dev_labels)):\n",
+ " # We only care about those where labels do not match predictions #\n",
+ " if dev_labels[i] != predictions[i] and (dev_labels[i] == 4 or dev_labels[i] == 9):\n",
+ " devp = dev_data[i].reshape(28,28)\n",
+ " count = count + 1\n",
+ " if count > 8:\n",
+ " break\n",
+ " # plot this as an example #\n",
+ " plt.subplot(4, 4, count)\n",
+ " plt.axis(\"off\")\n",
+ " plt.title(predictions[i])\n",
+ " plt.imshow(devp, aspect = \"auto\", cmap = plt.cm.gray_r, interpolation = \"nearest\")\n",
+ " \n",
+ "### STUDENT END ###\n",
+ "\n",
+ "P5()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " ANSWER: 4 & 9 Seems to be the most confused digits in the dev_data. The images above show why. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "(6) A common image processing technique is to smooth an image by blurring. The idea is that the value of a particular pixel is estimated as the weighted combination of the original value and the values around it. Typically, the blurring is Gaussian -- that is, the weight of a pixel's influence is determined by a Gaussian function over the distance to the relevant pixel.\n",
+ "\n",
+ "Implement a simplified Gaussian blur by just using the 8 neighboring pixels: the smoothed value of a pixel is a weighted combination of the original value and the 8 neighboring values. Try applying your blur filter in 3 ways:\n",
+ "- preprocess the training data but not the dev data\n",
+ "- preprocess the dev data but not the training data\n",
+ "- preprocess both training and dev data\n",
+ "\n",
+ "Note that there are Guassian blur filters available, for example in scipy.ndimage.filters. You're welcome to experiment with those, but you are likely to get the best results with the simplified version I described above."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def P6():\n",
+ " \n",
+ "### STUDENT START ###\n",
+ "\n",
+ " # Function to recalculate the value of a pixel from its 8 neighbors #\n",
+ " # We'll take an image (One dimentional array) as the input and return one that's been blurred\n",
+ " def gBlur(image, debug = False):\n",
+ " \n",
+ " # basic validation of the image. Is the array empty? #\n",
+ " if (len(image) == 0):\n",
+ " print(\"Error: We've got an array of lenght 0\")\n",
+ " return image\n",
+ " \n",
+ " # Print the input image for debugging #\n",
+ " if debug:\n",
+ " plt.subplot(1, 2, 1)\n",
+ " plt.imshow(image)\n",
+ " \n",
+ " # Making an empty numpy array to hold the retun value\n",
+ " newImage = np.empty((28, 28))\n",
+ " \n",
+ " # Now lets start walking through each pixel #\n",
+ " for i in range(len(image)):\n",
+ " for j in range(len(image[i])):\n",
+ " \n",
+ " # Now we have the pixel. Lets assume there's 8 around it #\n",
+ " # For the edges the pixels will wrap around, i.e we'll have negative indices #\n",
+ " \n",
+ " # Extracting a sub array to do the sum\n",
+ " subArray = image[i-1:i+2, j-1:j+2]\n",
+ " bFactor = (np.sum(subArray))/9\n",
+ " \n",
+ " # Replace the pixel with the new value #\n",
+ " newImage[i][j] = bFactor\n",
+ " \n",
+ " # print the output image for debugging #\n",
+ " if debug:\n",
+ " plt.subplot(1, 2, 2)\n",
+ " plt.imshow(newImage)\n",
+ " \n",
+ " return newImage\n",
+ " \n",
+ " #gBlur(mini_train_data[0].reshape(28,28), debug = True)\n",
+ " \n",
+ " # Function to apply the blurring to an array of images\n",
+ " def gBlurArray(imageArray, debug = False):\n",
+ " \n",
+ " # basic validation of the image. Is the array empty? #\n",
+ " if (len(imageArray) == 0):\n",
+ " print(\"Error: We've got an array of lenght 0\")\n",
+ " return imageArray\n",
+ " \n",
+ " # Creating an empty array for returning\n",
+ " newArray = np.empty(imageArray.shape)\n",
+ " \n",
+ " # Walking through the input image array and applying blur on each image\n",
+ " for i in range(len(imageArray)):\n",
+ " newArray[i] = gBlur(imageArray[i].reshape(28,28), debug = False).reshape(28*28)\n",
+ " \n",
+ " if debug:\n",
+ " # Print the before an after for one image from the array\n",
+ " plt.subplot(1, 2, 1)\n",
+ " plt.imshow(imageArray[300].reshape(28,28))\n",
+ " \n",
+ " plt.subplot(1, 2, 2)\n",
+ " plt.imshow(newArray[300].reshape(28, 28))\n",
+ " \n",
+ " return newArray\n",
+ " \n",
+ " # gBlurArray(mini_train_data, True)\n",
+ " \n",
+ " # Function to run knn model with training and dev data\n",
+ " def modKnn(train, trainLabels, dev, devLabels):\n",
+ " \n",
+ " # Create the knn model.\n",
+ " knnModel = KNeighborsClassifier(1)\n",
+ " \n",
+ " # Fit the model on mini training set\n",
+ " knnModel.fit(train, trainLabels)\n",
+ "\n",
+ " # Try on the development set\n",
+ " predictions = knnModel.predict(dev)\n",
+ " \n",
+ " # 2 metrics to get an idea of accuracy: Mean Squared Error and model score\n",
+ " \n",
+ " # Mean Squared error and accuracy \n",
+ " meanse = (((predictions - devLabels) ** 2).sum()) / len(predictions)\n",
+ " sc = knnModel.score(dev, devLabels)\n",
+ " \n",
+ " # Print the MSE and accuracy for a value of K\n",
+ " print(\"The Mean Square Error for K = \", 1, \" on the dev data set is \", meanse)\n",
+ " print(\"The accuracy is\", (sc*100), \"%\")\n",
+ " \n",
+ " # Knn model without any preprocessing on data\n",
+ " modKnn(mini_train_data, mini_train_labels, dev_data, dev_labels)\n",
+ " \n",
+ " # Lets do the model with preprocessing on the training data\n",
+ " modKnn(gBlurArray(mini_train_data), mini_train_labels, dev_data, dev_labels)\n",
+ " \n",
+ " # Trying the same with preprocessing on dev data\n",
+ " modKnn(mini_train_data, mini_train_labels, gBlurArray(dev_data), dev_labels)\n",
+ " \n",
+ " # Trying with preprocessing on both training and dev data\n",
+ " modKnn(gBlurArray(mini_train_data), mini_train_labels, gBlurArray(dev_data), dev_labels)\n",
+ "\n",
+ "### STUDENT END ###\n",
+ "\n",
+ "P6()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "ANSWER: There difference in Mean Square Error and accuracy with varying level of preprocessing\n",
+ "We get the most accuracy and smalles MSE by preprocessing the training data \n",
+ "\n",
+ "NO preprocessing\n",
+ "The Mean Square Error for K = 1 on the dev data set is 2.119\n",
+ "The accuracy is 88.8 %\n",
+ "\n",
+ "Preprocessing the training data\n",
+ "The Mean Square Error for K = 1 on the dev data set is 1.711\n",
+ "The accuracy is 90.9 %\n",
+ "\n",
+ "Preprocessing dev data only\n",
+ "The Mean Square Error for K = 1 on the dev data set is 2.504\n",
+ "The accuracy is 87.1 %\n",
+ "\n",
+ "Preprocessing both dev and training data\n",
+ "The Mean Square Error for K = 1 on the dev data set is 1.802\n",
+ "The accuracy is 90.3 %\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "(7) Fit a Naive Bayes classifier and report accuracy on the dev data. Remember that Naive Bayes estimates P(feature|label). While sklearn can handle real-valued features, let's start by mapping the pixel values to either 0 or 1. You can do this as a preprocessing step, or with the binarize argument. With binary-valued features, you can use BernoulliNB. Next try mapping the pixel values to 0, 1, or 2, representing white, grey, or black. This mapping requires MultinomialNB. Does the multi-class version improve the results? Why or why not?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 208,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "The Mean Square Error on the dev data set with Bernoulli NB is 3.027\n",
+ "The accuracy is 81.5 %\n",
+ "\n",
+ "The Mean Square Error on the dev data set with Multinomial NB is 3.382\n",
+ "The accuracy is 79.4 %\n",
+ "\n",
+ "The Mean Square Error on the dev data set with Multinomial NB (features in a {0, 1, 2} set) is 3.255\n",
+ "The accuracy is 79.4 %\n"
+ ]
+ }
+ ],
+ "source": [
+ "def P7():\n",
+ "\n",
+ "### STUDENT START ###\n",
+ "\n",
+ " # Create the model\n",
+ " BNbModel = BernoulliNB()\n",
+ " \n",
+ " # Fitting the model on the mini training set\n",
+ " BNbModel.fit(mini_train_data, mini_train_labels)\n",
+ " BernoulliNB(alpha=1.0, binarize=0.0, class_prior=None, fit_prior=True)\n",
+ " \n",
+ " # Predictions on Dev data\n",
+ " predictions = BNbModel.predict(dev_data)\n",
+ " \n",
+ " # Mean Squared error and accuracy\n",
+ " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n",
+ " sc = BNbModel.score(dev_data, dev_labels)\n",
+ "\n",
+ " # Print the MSE and accuracy\n",
+ " print()\n",
+ " print(\"The Mean Square Error on the dev data set with Bernoulli NB is \", meanse)\n",
+ " print(\"The accuracy is\", (sc*100), \"%\")\n",
+ " print()\n",
+ " \n",
+ " \n",
+ " # Doing the same with MultinomialNB without any transforms\n",
+ " \n",
+ " # Create the model\n",
+ " MNbModel = MultinomialNB()\n",
+ " \n",
+ " # Fitting the model on the mini training set\n",
+ " MNbModel.fit(mini_train_data, mini_train_labels)\n",
+ " MultinomialNB(alpha=1.0,class_prior=None, fit_prior=True)\n",
+ " \n",
+ " # Predictions on Dev data\n",
+ " predictions = MNbModel.predict(dev_data)\n",
+ " \n",
+ " # Mean Squared error and accuracy\n",
+ " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n",
+ " sc = MNbModel.score(dev_data, dev_labels)\n",
+ "\n",
+ " # Print the MSE and accuracy\n",
+ " print(\"The Mean Square Error on the dev data set with Multinomial NB is \", meanse)\n",
+ " print(\"The accuracy is\", (sc*100), \"%\")\n",
+ " print()\n",
+ " \n",
+ " # Function to transform pixel values\n",
+ " def tr(imageInput):\n",
+ " image = np.copy(imageInput)\n",
+ " for i in range(len(image)):\n",
+ " if image[i] == 0:\n",
+ " continue\n",
+ " if image[i] < .75:\n",
+ " image[i] = 1\n",
+ " continue\n",
+ " if image[i] > .75:\n",
+ " image[i] = 2\n",
+ " return image\n",
+ " \n",
+ " # Function to apply 0, 1, 2 transform to data array\n",
+ " def trArray(imageInputArray):\n",
+ " imageArray = np.copy(imageInputArray)\n",
+ " for i in range(len(imageArray)):\n",
+ " imageArray[i] = tr(imageInputArray[i])\n",
+ " return imageArray\n",
+ " \n",
+ " # Repeating the Multinomial model\n",
+ " # Create the model\n",
+ " MNbModel1 = MultinomialNB()\n",
+ " \n",
+ " # Fitting the model on the mini training set\n",
+ " MNbModel1.fit(trArray(mini_train_data), mini_train_labels)\n",
+ " MultinomialNB(alpha=1.0,class_prior=None, fit_prior=True)\n",
+ " \n",
+ " # Predictions on Dev data\n",
+ " predictions = MNbModel1.predict(trArray(dev_data))\n",
+ " \n",
+ " # Mean Squared error and accuracy\n",
+ " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n",
+ " sc = MNbModel1.score(trArray(dev_data), dev_labels)\n",
+ "\n",
+ " # Print the MSE and accuracy\n",
+ " print(\"The Mean Square Error on the dev data set with Multinomial NB (features in a {0, 1, 2} set) is \", meanse)\n",
+ " print(\"The accuracy is\", (sc*100), \"%\")\n",
+ " \n",
+ "### STUDENT END ###\n",
+ "\n",
+ "P7()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "ANSWER: The multinomial function improves the results by just a little bit\n",
+ "The accuracy with binary and multinomial function is about the same ~79%\n",
+ "The Mean Square Error with Multiclass reduces from 3.382 to 3.255\n",
+ "\n",
+ "The improvement is not dramatic due to he nature of the features. The binary transform already captures most of the difference among the features"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "(8) Use GridSearchCV to perform a search over values of alpha (the Laplace smoothing parameter) in a Bernoulli NB model. What is the best value for alpha? What is the accuracy when alpha=0? Is this what you'd expect?\n",
+ "\n",
+ "- Note that GridSearchCV partitions the training data so the results will be a bit different than if you used the dev data for evaluation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/sklearn/naive_bayes.py:472: UserWarning: alpha too small will result in numeric errors, setting alpha = 1.0e-10\n",
+ " 'setting alpha = %.1e' % _ALPHA_MIN)\n",
+ "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/sklearn/naive_bayes.py:472: UserWarning: alpha too small will result in numeric errors, setting alpha = 1.0e-10\n",
+ " 'setting alpha = %.1e' % _ALPHA_MIN)\n",
+ "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/sklearn/naive_bayes.py:472: UserWarning: alpha too small will result in numeric errors, setting alpha = 1.0e-10\n",
+ " 'setting alpha = %.1e' % _ALPHA_MIN)\n",
+ "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/sklearn/naive_bayes.py:472: UserWarning: alpha too small will result in numeric errors, setting alpha = 1.0e-10\n",
+ " 'setting alpha = %.1e' % _ALPHA_MIN)\n",
+ "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/sklearn/naive_bayes.py:472: UserWarning: alpha too small will result in numeric errors, setting alpha = 1.0e-10\n",
+ " 'setting alpha = %.1e' % _ALPHA_MIN)\n"
+ ]
+ }
+ ],
+ "source": [
+ "def P8(alphas):\n",
+ "\n",
+ "### STUDENT START ###\n",
+ "\n",
+ " #GridSearchCV to perform a search over values of alpha \n",
+ " #(the Laplace smoothing parameter) in a Bernoulli NB model.\n",
+ " \n",
+ " # Create the model\n",
+ " BNbModel1 = BernoulliNB()\n",
+ " \n",
+ " # Setting the parameters under consideration\n",
+ " pTune = [alphas]\n",
+ " \n",
+ " # Some test code\n",
+ " # BNbModel1.fit(mini_train_data, mini_train_labels)\n",
+ " # BernoulliNB(alpha=1.0, binarize=0.0, class_prior=None, fit_prior=True)\n",
+ " \n",
+ " # Tuning alpha\n",
+ " GS = GridSearchCV(BernoulliNB(binarize=0.0), pTune, cv=5)\n",
+ " GS.fit(mini_train_data, mini_train_labels)\n",
+ " \n",
+ " # Some play and test code\n",
+ " # means = GS.cv_results_['mean_test_score']\n",
+ " # stds = GS.cv_results_['std_test_score']\n",
+ " \n",
+ " #for mean, std, params in zip(means, stds, GS.cv_results_['params']):\n",
+ " # print(\"%0.3f (+/-%0.03f) for %r\"\n",
+ " # % (mean, std * 2, params)) \n",
+ "\n",
+ " # actuals, predictions = dev_labels, GS.predict(dev_data)\n",
+ " # print(classification_report(dev_labels, dev_data))\n",
+ " # print()\n",
+ " \n",
+ " return GS\n",
+ " \n",
+ "### STUDENT END ###\n",
+ "\n",
+ "alphas = {'alpha': [0.0, 0.0001, 0.001, 0.01, 0.1, 0.5, 1.0, 2.0, 10.0]}\n",
+ "# Replacing the array to remove some runtime warnings on processing of 0 and small values #\n",
+ "# Using the original though as the Q is about alpha = 0\n",
+ "# alphas = {'alpha': [0.00001, 0.0001, 0.001, 0.01, 0.1, 0.5, 1.0, 2.0, 10.0]}\n",
+ "nb = P8(alphas)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "For best score {'alpha': 0.0001}\n",
+ "\n",
+ "All scores\n",
+ "\n",
+ "0.810 (+/-0.034) for {'alpha': 0.0}\n",
+ "0.823 (+/-0.042) for {'alpha': 0.0001}\n",
+ "0.823 (+/-0.039) for {'alpha': 0.001}\n",
+ "0.819 (+/-0.044) for {'alpha': 0.01}\n",
+ "0.819 (+/-0.043) for {'alpha': 0.1}\n",
+ "0.817 (+/-0.045) for {'alpha': 0.5}\n",
+ "0.817 (+/-0.048) for {'alpha': 1.0}\n",
+ "0.812 (+/-0.047) for {'alpha': 2.0}\n",
+ "0.786 (+/-0.054) for {'alpha': 10.0}\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Best parameter (alpha)\n",
+ "\n",
+ "print(\"For best score \", nb.best_params_)\n",
+ "print()\n",
+ "\n",
+ "# Finding scores for all values of alpha\n",
+ "means = nb.cv_results_['mean_test_score']\n",
+ "stds = nb.cv_results_['std_test_score']\n",
+ "\n",
+ "print (\"All scores\\n\")\n",
+ " \n",
+ "for mean, std, params in zip(means, stds, nb.cv_results_['params']):\n",
+ " print(\"%0.3f (+/-%0.03f) for %r\" % (mean, std * 2, params)) \n",
+ "\n",
+ " # actuals, predictions = dev_labels, GS.predict(dev_data)\n",
+ " # print(classification_report(dev_labels, dev_data))\n",
+ " # print()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "ANSWER:\n",
+ "\n",
+ "What is the best value for alpha? .0001\n",
+ "\n",
+ "What is the accuracy when alpha=0? 81%\n",
+ "\n",
+ "Is this what you'd expect? Yes, we'll expect smoothing to increase the accuracy by a small % as is visible from the results below\n",
+ "\n",
+ "0.810 (+/-0.034) for {'alpha': 0.0}\n",
+ "0.823 (+/-0.042) for {'alpha': 0.0001}\n",
+ "0.823 (+/-0.039) for {'alpha': 0.001}\n",
+ "0.819 (+/-0.044) for {'alpha': 0.01}\n",
+ "0.819 (+/-0.043) for {'alpha': 0.1}\n",
+ "0.817 (+/-0.045) for {'alpha': 0.5}\n",
+ "0.817 (+/-0.048) for {'alpha': 1.0}\n",
+ "0.812 (+/-0.047) for {'alpha': 2.0}\n",
+ "0.786 (+/-0.054) for {'alpha': 10.0}\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "(9) Try training a model using GuassianNB, which is intended for real-valued features, and evaluate on the dev data. You'll notice that it doesn't work so well. Try to diagnose the problem. You should be able to find a simple fix that returns the accuracy to around the same rate as BernoulliNB. Explain your solution.\n",
+ "\n",
+ "Hint: examine the parameters estimated by the fit() method, theta\\_ and sigma\\_."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 147,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The Mean Square Error on the dev data set is 6.441\n",
+ "The accuracy is 62.1 %\n",
+ "\n",
+ "Model parameters\n",
+ "{'priors': None}\n",
+ "\n",
+ "The Mean Square Error on the dev data set 5.374\n",
+ "The accuracy is 62.8 %\n",
+ "\n",
+ "\n",
+ "The Mean Square Error on the dev data set is 5.998\n",
+ "The accuracy is 63.6 %\n"
+ ]
+ }
+ ],
+ "source": [
+ "def P9():\n",
+ "\n",
+ "### STUDENT START ###\n",
+ "\n",
+ " # GaussianNB\n",
+ " # Create the model\n",
+ " GNbModel = GaussianNB()\n",
+ " \n",
+ " # Fitting the model on the mini training set\n",
+ " GNbModel.fit(mini_train_data, mini_train_labels)\n",
+ " GaussianNB(priors = None)\n",
+ " \n",
+ " # Predictions on Dev data\n",
+ " predictions = GNbModel.predict(dev_data)\n",
+ " \n",
+ " # Mean Squared error and accuracy\n",
+ " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n",
+ " sc = GNbModel.score(dev_data, dev_labels)\n",
+ "\n",
+ " # Print the MSE and accuracy\n",
+ " print(\"The Mean Square Error on the dev data set is \", meanse)\n",
+ " print(\"The accuracy is\", (sc*100), \"%\")\n",
+ " \n",
+ " # The accuracy on dev. data is ~62%. Trying to figure out what's going on\n",
+ " \n",
+ " # Checking the parameters\n",
+ " print()\n",
+ " print(\"Model parameters\")\n",
+ " print(GNbModel.get_params(deep = True))\n",
+ " print()\n",
+ " \n",
+ " # Changing the feature values to increase accuracy\n",
+ " \n",
+ " # Binary feature values\n",
+ " # Copy the training data\n",
+ " miniTr1 = mini_train_data.copy()\n",
+ " \n",
+ " # Replace with 0 and 1\n",
+ " miniTr1[miniTr1 < .5] = 0\n",
+ " miniTr1[miniTr1 >= .5] = 1\n",
+ " \n",
+ " # Trying out the model\n",
+ " \n",
+ " GNbModel1 = GaussianNB()\n",
+ " GNbModel1.fit(miniTr1, mini_train_labels)\n",
+ " GaussianNB(priors = None)\n",
+ " predictions = GNbModel1.predict(dev_data)\n",
+ " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n",
+ " sc = GNbModel1.score(dev_data, dev_labels)\n",
+ "\n",
+ " # Print the MSE and accuracy\n",
+ " print(\"The Mean Square Error on the dev data set \", meanse)\n",
+ " print(\"The accuracy is\", (sc*100), \"%\")\n",
+ " print()\n",
+ " \n",
+ " # Trying to make the prediction with modified dev_data\n",
+ " dev1 = dev_data.copy()\n",
+ " dev1[dev1 < .5] = 0\n",
+ " dev1[dev1 >= .5] = 1\n",
+ " predictions = GNbModel1.predict(dev1)\n",
+ " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n",
+ " sc = GNbModel1.score(dev1, dev_labels)\n",
+ "\n",
+ " # Print the MSE and accuracy\n",
+ " print()\n",
+ " print(\"The Mean Square Error on the dev data set is \", meanse)\n",
+ " print(\"The accuracy is\", (sc*100), \"%\")\n",
+ "\n",
+ "### STUDENT END ###\n",
+ "\n",
+ "gnb = P9()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "ANSWER: \n",
+ "\n",
+ "The Mean Square Error on the dev data set is 6.441\n",
+ "The accuracy is 62.1 %\n",
+ "\n",
+ "The accuracy with Gaussian Naive Bayes is ~20% less than with Bernaulli \n",
+ "\n",
+ "The accuracy seems to increase by categorization (0,1) on both training and dev data, but not by much (~1% to 63.6%)\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "(10) Because Naive Bayes is a generative model, we can use the trained model to generate digits. Train a BernoulliNB model and then generate a 10x20 grid with 20 examples of each digit. Because you're using a Bernoulli model, each pixel output will be either 0 or 1. How do the generated digits compare to the training digits?\n",
+ "\n",
+ "- You can use np.random.rand() to generate random numbers from a uniform distribution\n",
+ "- The estimated probability of each pixel is stored in feature\\_log\\_prob\\_. You'll need to use np.exp() to convert a log probability back to a probability."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 104,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The Mean Square Error on the dev data set is 3.027\n",
+ "The accuracy is 81.5 %\n",
+ "\n",
+ "The shape of the probability estimates/class array\n",
+ "(10, 784)\n",
+ "\n",
+ "The generated digits\n",
+ "\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def P10(num_examples):\n",
+ "\n",
+ "### STUDENT START ###\n",
+ " # Training the NB Model and testing for accuracy\n",
+ " \n",
+ " # Create the model\n",
+ " BNbModel = BernoulliNB()\n",
+ " \n",
+ " # Fitting the model on the mini training set\n",
+ " BNbModel.fit(mini_train_data, mini_train_labels)\n",
+ " BernoulliNB(alpha=1.0, binarize=0.0, class_prior=None, fit_prior=True)\n",
+ " \n",
+ " # Predictions on Dev data\n",
+ " predictions = BNbModel.predict(dev_data)\n",
+ " \n",
+ " # Mean Squared error and accuracy\n",
+ " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n",
+ " sc = BNbModel.score(dev_data, dev_labels)\n",
+ "\n",
+ " # Print the MSE and accuracy\n",
+ " print(\"The Mean Square Error on the dev data set is \", meanse)\n",
+ " print(\"The accuracy is\", (sc*100), \"%\")\n",
+ " \n",
+ " # Reasonable accuracy, moving on to generating\n",
+ " \n",
+ " # Finding out the probability estimates for each class (digit)\n",
+ " print()\n",
+ " print(\"The shape of the probability estimates/class array\")\n",
+ " print(BNbModel.feature_log_prob_.shape)\n",
+ " print()\n",
+ " \n",
+ " # We have a 10 (digits) * 784 matrix that's the probability of each pixel\n",
+ " # print(np.exp(BNbModel.feature_log_prob_ ))\n",
+ " \n",
+ " # Making a 10*num_examples array. Each example is a 28*28 array\n",
+ " print(\"The generated digits\")\n",
+ " print()\n",
+ " digArray = np.empty((10,20,28,28))\n",
+ " count = 0\n",
+ " for i in range(len(digArray)):\n",
+ " for j in range(len(digArray[i])):\n",
+ " \n",
+ " # generating just random values corresponding to a digit\n",
+ " digArray[i][j] = np.random.rand(28,28)\n",
+ " \n",
+ " # Now we get the feature probability matrix corresponding to this digit\n",
+ " # The product of the random array and feature probability is the digit\n",
+ " digArray[i][j] = digArray[i][j] * (np.exp(BNbModel.feature_log_prob_ ))[i].reshape(28,28)\n",
+ " \n",
+ " # Plotting the digit\n",
+ " count = count + 1\n",
+ " plt.subplot(10, num_examples, count)\n",
+ " plt.axis(\"off\")\n",
+ " plt.imshow(digArray[i][j], aspect = \"auto\", cmap = plt.cm.gray_r, interpolation = \"nearest\")\n",
+ " \n",
+ " # TODO Not urgent, but got to figure out how to make bigger matrix plots\n",
+ "\n",
+ "### STUDENT END ###\n",
+ "\n",
+ "P10(20)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "ANSWER: The generated images can be recognized as such(digigs) but are blurry, especially at the edges. It the same kind of impact you get by blurring."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "(11) Remember that a strongly calibrated classifier is rougly 90% accurate when the posterior probability of the predicted class is 0.9. A weakly calibrated classifier is more accurate when the posterior is 90% than when it is 80%. A poorly calibrated classifier has no positive correlation between posterior and accuracy.\n",
+ "\n",
+ "Train a BernoulliNB model with a reasonable alpha value. For each posterior bucket (think of a bin in a histogram), you want to estimate the classifier's accuracy. So for each prediction, find the bucket the maximum posterior belongs to and update the \"correct\" and \"total\" counters.\n",
+ "\n",
+ "How would you characterize the calibration for the Naive Bayes model?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 93,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The Mean Square Error on the dev data set is 3.027\n",
+ "The accuracy is 81.5 %\n",
+ "\n",
+ "The shape of probability array for dev_data\n",
+ "(1000, 10)\n",
+ "\n",
+ "The probability accuracy matrix\n",
+ "p(pred) <= 0.9000000000000 total = 28 accuracy = 0.536\n",
+ "p(pred) <= 0.9990000000000 total = 70 accuracy = 0.429\n",
+ "p(pred) <= 0.9999900000000 total = 59 accuracy = 0.508\n",
+ "p(pred) <= 0.9999999000000 total = 63 accuracy = 0.571\n",
+ "p(pred) <= 0.9999999990000 total = 57 accuracy = 0.632\n",
+ "p(pred) <= 0.9999999999900 total = 66 accuracy = 0.712\n",
+ "p(pred) <= 0.9999999999999 total = 56 accuracy = 0.857\n",
+ "p(pred) <= 1.0000000000000 total = 601 accuracy = 0.953\n"
+ ]
+ }
+ ],
+ "source": [
+ "def P11(buckets, correct, total):\n",
+ " \n",
+ "### STUDENT START ###\n",
+ "\n",
+ " # Training a bernaulliNB model\n",
+ " # Create the model\n",
+ " BNbModel = BernoulliNB()\n",
+ " \n",
+ " # Fitting the model on the mini training set\n",
+ " BNbModel.fit(mini_train_data, mini_train_labels)\n",
+ " BernoulliNB(alpha=1.0, binarize=0.0, class_prior=None, fit_prior=True)\n",
+ " \n",
+ " # Predictions on Dev data\n",
+ " predictions = BNbModel.predict(dev_data)\n",
+ " \n",
+ " # Mean Squared error and accuracy\n",
+ " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n",
+ " sc = BNbModel.score(dev_data, dev_labels)\n",
+ "\n",
+ " # Print the MSE and accuracy\n",
+ " print(\"The Mean Square Error on the dev data set is \", meanse)\n",
+ " print(\"The accuracy is\", (sc*100), \"%\")\n",
+ " \n",
+ " # Finding the probabilties for a class for each of the dev_data\n",
+ " prob = BNbModel.predict_proba(dev_data)\n",
+ " print()\n",
+ " print(\"The shape of probability array for dev_data\")\n",
+ " print(prob.shape)\n",
+ " print()\n",
+ "\n",
+ " for i in range(len(predictions)):\n",
+ " for j in range(len(buckets)):\n",
+ " if (buckets[j-1] < np.max(prob[i]) <= buckets[j]):\n",
+ " total[j] = total[j] + 1\n",
+ " if predictions[i] == dev_labels[i]:\n",
+ " correct[j] = correct[j] + 1\n",
+ " \n",
+ "### STUDENT END ###\n",
+ "\n",
+ "buckets = [0.5, 0.9, 0.999, 0.99999, 0.9999999, 0.999999999, 0.99999999999, 0.9999999999999, 1.0]\n",
+ "correct = [0 for i in buckets]\n",
+ "total = [0 for i in buckets]\n",
+ "\n",
+ "P11(buckets, correct, total)\n",
+ "\n",
+ "print(\"The probability accuracy matrix\")\n",
+ "for i in range(len(buckets)):\n",
+ " accuracy = 0.0\n",
+ " if (total[i] > 0): \n",
+ " accuracy = correct[i] / total[i]\n",
+ " print (\"p(pred) <= %.13f total = %3d accuracy = %.3f\" %(buckets[i], total[i], accuracy))\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "ANSWER: Above analysis of BernaulliNB shows the following:\n",
+ "\n",
+ "1. At prediction probability of .9 the classifier is ~50% accurate\n",
+ "2. Except in the lowest 3 buckets, the accuracy is increasing with prediction probability\n",
+ "3. The accuracy is ~95% when the digit is almost an exact match\n",
+ "\n",
+ "In the current form, our classifier is weakly calibrated. There is definately a positive correlation among probability and accuracy so we cannot conclude that the classifier is poorly calibrated"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "(12) EXTRA CREDIT\n",
+ "\n",
+ "Try designing extra features to see if you can improve the performance of Naive Bayes on the dev set. Here are a few ideas to get you started:\n",
+ "- Try summing the pixel values in each row and each column.\n",
+ "- Try counting the number of enclosed regions; 8 usually has 2 enclosed regions, 9 usually has 1, and 7 usually has 0.\n",
+ "\n",
+ "Make sure you comment your code well!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 209,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The Mean Square Error on the dev data set of the base model is 3.027\n",
+ "The accuracy of base model is 81.5 %\n",
+ "\n",
+ "The Mean Square Error on the dev data set of the base model with full training set is 2.717\n",
+ "The accuracy of base model with full training set is 82.6 %\n",
+ "\n",
+ "The Mean Square Error on the dev data set with a Multinomial model is 2.719\n",
+ "The accuracy with multinomial model is 82.6 %\n",
+ "\n",
+ "The Mean Square Error on the dev data set with a Multinomial model that accentuates information is 2.683\n",
+ "The accuracy with multinomial model that accentuates information is 82.7 %\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "def P12():\n",
+ "\n",
+ "### STUDENT START ###\n",
+ "\n",
+ "# Training a BernoulliNB model\n",
+ "\n",
+ " # Create the model\n",
+ " BNbModel = BernoulliNB()\n",
+ " \n",
+ " # Fitting the model on the mini training set\n",
+ " BNbModel.fit(mini_train_data, mini_train_labels)\n",
+ " BernoulliNB(alpha=.0001, binarize=0.0, class_prior=None, fit_prior=True)\n",
+ " \n",
+ " # Predictions on Dev data\n",
+ " predictions = BNbModel.predict(dev_data)\n",
+ " \n",
+ " # Mean Squared error and accuracy\n",
+ " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n",
+ " sc = BNbModel.score(dev_data, dev_labels)\n",
+ "\n",
+ " # Print the MSE and accuracy\n",
+ " print(\"The Mean Square Error on the dev data set of the base model is \", meanse)\n",
+ " print(\"The accuracy of base model is\", (sc*100), \"%\")\n",
+ " print()\n",
+ " \n",
+ " #########################################################\n",
+ " \n",
+ " # Does the accuracy increase by training with more data #\n",
+ " \n",
+ " # Fitting the model on the mini training set\n",
+ " BNbModel.fit(train_data, train_labels)\n",
+ " BernoulliNB(alpha=.0001, binarize=0.0, class_prior=None, fit_prior=True)\n",
+ " \n",
+ " # Predictions on Dev data\n",
+ " predictions = BNbModel.predict(dev_data)\n",
+ " \n",
+ " # Mean Squared error and accuracy\n",
+ " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n",
+ " sc = BNbModel.score(dev_data, dev_labels)\n",
+ "\n",
+ " # Print the MSE and accuracy\n",
+ " print(\"The Mean Square Error on the dev data set of the base model with full training set is \", meanse)\n",
+ " print(\"The accuracy of base model with full training set is\", (sc*100), \"%\")\n",
+ " print()\n",
+ " \n",
+ " #########################################################\n",
+ " \n",
+ " # Trying the multinomial model #\n",
+ " \n",
+ " # Create the model\n",
+ " MNbModel1 = MultinomialNB()\n",
+ " \n",
+ " # Fitting the model on the mini training set\n",
+ " MNbModel1.fit(train_data, train_labels)\n",
+ " MultinomialNB(alpha=.0001,class_prior=None, fit_prior=True)\n",
+ " \n",
+ " # Predictions on Dev data\n",
+ " predictions = MNbModel1.predict(dev_data)\n",
+ " \n",
+ " # Mean Squared error and accuracy\n",
+ " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n",
+ " sc = MNbModel1.score(dev_data, dev_labels)\n",
+ "\n",
+ " # Print the MSE and accuracy\n",
+ " print(\"The Mean Square Error on the dev data set with a Multinomial model is \", meanse)\n",
+ " print(\"The accuracy with multinomial model is\", (sc*100), \"%\")\n",
+ " print()\n",
+ " \n",
+ " #########################################################\n",
+ " \n",
+ " # Lets try to accentuate the features of the digit #\n",
+ " # We'll highlight everything that has a little more information than 0#\n",
+ " \n",
+ " # Creating a new training set with middle of the image highlighted\n",
+ " def tHighlight(data):\n",
+ " hTrain = np.copy(data)\n",
+ " hTrain[hTrain > .001] = hTrain[hTrain > .001] * 255\n",
+ " return hTrain\n",
+ " \n",
+ " \n",
+ " # Fitting the model on the mini training set\n",
+ " MNbModel1.fit(tHighlight(train_data), train_labels)\n",
+ " MultinomialNB(alpha=.0001,class_prior=None, fit_prior=True)\n",
+ " \n",
+ " # Predictions on Dev data\n",
+ " predictions = MNbModel1.predict(tHighlight(dev_data))\n",
+ " \n",
+ " # Mean Squared error and accuracy\n",
+ " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n",
+ " sc = MNbModel1.score(tHighlight(dev_data), dev_labels)\n",
+ "\n",
+ " # Print the MSE and accuracy\n",
+ " print(\"The Mean Square Error on the dev data set with a Multinomial model that accentuates information is \", meanse)\n",
+ " print(\"The accuracy with multinomial model that accentuates information is\", (sc*100), \"%\")\n",
+ " print()\n",
+ " \n",
+ " \n",
+ " #########################################################\n",
+ " \n",
+ " \n",
+ "\n",
+ "### STUDENT END ###\n",
+ "\n",
+ "P12()"
+ ]
+ },
+ {
+ "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.6.4"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/Homework/firstname_lastname_p1.ipynb b/Homework/firstname_lastname_p1.ipynb
deleted file mode 100644
index c29cadb..0000000
--- a/Homework/firstname_lastname_p1.ipynb
+++ /dev/null
@@ -1,548 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Project 1: Digit Classification with KNN and Naive Bayes"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "In this project, you'll implement your own image recognition system for classifying digits. Read through the code and the instructions carefully and add your own code where indicated. Each problem can be addressed succinctly with the included packages -- please don't add any more. Grading will be based on writing clean, commented code, along with a few short answers.\n",
- "\n",
- "As always, you're welcome to work on the project in groups and discuss ideas on the course wall, but please prepare your own write-up (with your own code). \n",
- "\n",
- "If you're interested, check out these links related to digit recognition:\n",
- "\n",
- "Yann Lecun's MNIST benchmarks: http://yann.lecun.com/exdb/mnist/\n",
- "\n",
- "Stanford Streetview research and data: http://ufldl.stanford.edu/housenumbers/"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "# This tells matplotlib not to try opening a new window for each plot.\n",
- "%matplotlib inline\n",
- "\n",
- "# Import a bunch of libraries.\n",
- "import time\n",
- "import numpy as np\n",
- "import matplotlib.pyplot as plt\n",
- "from matplotlib.ticker import MultipleLocator\n",
- "from sklearn.pipeline import Pipeline\n",
- "from sklearn.datasets import fetch_mldata\n",
- "from sklearn.neighbors import KNeighborsClassifier\n",
- "from sklearn.metrics import confusion_matrix\n",
- "from sklearn.linear_model import LinearRegression\n",
- "from sklearn.naive_bayes import BernoulliNB\n",
- "from sklearn.naive_bayes import MultinomialNB\n",
- "from sklearn.naive_bayes import GaussianNB\n",
- "from sklearn.grid_search import GridSearchCV\n",
- "from sklearn.metrics import classification_report\n",
- "\n",
- "# Set the randomizer seed so results are the same each time.\n",
- "np.random.seed(0)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Load the data. Notice that we are splitting the data into training, development, and test. We also have a small subset of the training data called mini_train_data and mini_train_labels that you should use in all the experiments below, unless otherwise noted."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "data shape: (70000, 784)\n",
- "label shape: (70000,)\n"
- ]
- }
- ],
- "source": [
- "# Load the digit data either from mldata.org, or once downloaded to data_home, from disk. The data is about 53MB so this cell\n",
- "# should take a while the first time your run it.\n",
- "mnist = fetch_mldata('MNIST original', data_home='~/datasets/mnist')\n",
- "X, Y = mnist.data, mnist.target\n",
- "\n",
- "# Rescale grayscale values to [0,1].\n",
- "X = X / 255.0\n",
- "\n",
- "# Shuffle the input: create a random permutation of the integers between 0 and the number of data points and apply this\n",
- "# permutation to X and Y.\n",
- "# NOTE: Each time you run this cell, you'll re-shuffle the data, resulting in a different ordering.\n",
- "shuffle = np.random.permutation(np.arange(X.shape[0]))\n",
- "X, Y = X[shuffle], Y[shuffle]\n",
- "\n",
- "print 'data shape: ', X.shape\n",
- "print 'label shape:', Y.shape\n",
- "\n",
- "# Set some variables to hold test, dev, and training data.\n",
- "test_data, test_labels = X[61000:], Y[61000:]\n",
- "dev_data, dev_labels = X[60000:61000], Y[60000:61000]\n",
- "train_data, train_labels = X[:60000], Y[:60000]\n",
- "mini_train_data, mini_train_labels = X[:1000], Y[:1000]"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "(1) Create a 10x10 grid to visualize 10 examples of each digit. Python hints:\n",
- "\n",
- "- plt.rc() for setting the colormap, for example to black and white\n",
- "- plt.subplot() for creating subplots\n",
- "- plt.imshow() for rendering a matrix\n",
- "- np.array.reshape() for reshaping a 1D feature vector into a 2D matrix (for rendering)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#def P1(num_examples=10):\n",
- "\n",
- "### STUDENT START ###\n",
- " \n",
- "\n",
- "### STUDENT END ###\n",
- "\n",
- "#P1(10)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "(2) Evaluate a K-Nearest-Neighbors model with k = [1,3,5,7,9] using the mini training set. Report accuracy on the dev set. For k=1, show precision, recall, and F1 for each label. Which is the most difficult digit?\n",
- "\n",
- "- KNeighborsClassifier() for fitting and predicting\n",
- "- classification_report() for producing precision, recall, F1 results"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#def P2(k_values):\n",
- "\n",
- "### STUDENT START ###\n",
- "\n",
- "\n",
- " \n",
- "### STUDENT END ###\n",
- "\n",
- "#k_values = [1, 3, 5, 7, 9]\n",
- "#P2(k_values)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "ANSWER:"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "(3) Using k=1, report dev set accuracy for the training set sizes below. Also, measure the amount of time needed for prediction with each training size.\n",
- "\n",
- "- time.time() gives a wall clock value you can use for timing operations"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#def P3(train_sizes, accuracies):\n",
- "\n",
- "### STUDENT START ###\n",
- "\n",
- "\n",
- "### STUDENT END ###\n",
- "\n",
- "#train_sizes = [100, 200, 400, 800, 1600, 3200, 6400, 12800, 25000]\n",
- "#accuracies = []\n",
- "#P3(train_sizes, accuracies)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "(4) Fit a regression model that predicts accuracy from training size. What does it predict for n=60000? What's wrong with using regression here? Can you apply a transformation that makes the predictions more reasonable?\n",
- "\n",
- "- Remember that the sklearn fit() functions take an input matrix X and output vector Y. So each input example in X is a vector, even if it contains only a single value."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#def P4():\n",
- "\n",
- "### STUDENT START ###\n",
- " \n",
- "\n",
- "### STUDENT END ###\n",
- "\n",
- "#P4()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "ANSWER:"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Fit a 1-NN and output a confusion matrix for the dev data. Use the confusion matrix to identify the most confused pair of digits, and display a few example mistakes.\n",
- "\n",
- "- confusion_matrix() produces a confusion matrix"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#def P5():\n",
- "\n",
- "### STUDENT START ###\n",
- "\n",
- " \n",
- "### STUDENT END ###\n",
- "\n",
- "#P5()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "(6) A common image processing technique is to smooth an image by blurring. The idea is that the value of a particular pixel is estimated as the weighted combination of the original value and the values around it. Typically, the blurring is Gaussian -- that is, the weight of a pixel's influence is determined by a Gaussian function over the distance to the relevant pixel.\n",
- "\n",
- "Implement a simplified Gaussian blur by just using the 8 neighboring pixels: the smoothed value of a pixel is a weighted combination of the original value and the 8 neighboring values. Try applying your blur filter in 3 ways:\n",
- "- preprocess the training data but not the dev data\n",
- "- preprocess the dev data but not the training data\n",
- "- preprocess both training and dev data\n",
- "\n",
- "Note that there are Guassian blur filters available, for example in scipy.ndimage.filters. You're welcome to experiment with those, but you are likely to get the best results with the simplified version I described above."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#def P6():\n",
- " \n",
- "### STUDENT START ###\n",
- "\n",
- "\n",
- "### STUDENT END ###\n",
- "\n",
- "#P6()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "ANSWER:"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "(7) Fit a Naive Bayes classifier and report accuracy on the dev data. Remember that Naive Bayes estimates P(feature|label). While sklearn can handle real-valued features, let's start by mapping the pixel values to either 0 or 1. You can do this as a preprocessing step, or with the binarize argument. With binary-valued features, you can use BernoulliNB. Next try mapping the pixel values to 0, 1, or 2, representing white, grey, or black. This mapping requires MultinomialNB. Does the multi-class version improve the results? Why or why not?"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#def P7():\n",
- "\n",
- "### STUDENT START ###\n",
- "\n",
- "\n",
- " \n",
- "### STUDENT END ###\n",
- "\n",
- "#P7()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "ANSWER:"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "(8) Use GridSearchCV to perform a search over values of alpha (the Laplace smoothing parameter) in a Bernoulli NB model. What is the best value for alpha? What is the accuracy when alpha=0? Is this what you'd expect?\n",
- "\n",
- "- Note that GridSearchCV partitions the training data so the results will be a bit different than if you used the dev data for evaluation."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 12,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#def P8(alphas):\n",
- "\n",
- "### STUDENT START ###\n",
- "\n",
- "\n",
- "\n",
- "### STUDENT END ###\n",
- "\n",
- "#alphas = {'alpha': [0.0, 0.0001, 0.001, 0.01, 0.1, 0.5, 1.0, 2.0, 10.0]}\n",
- "#nb = P8(alphas)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 14,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#print nb.best_params_"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "ANSWER:"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "(9) Try training a model using GuassianNB, which is intended for real-valued features, and evaluate on the dev data. You'll notice that it doesn't work so well. Try to diagnose the problem. You should be able to find a simple fix that returns the accuracy to around the same rate as BernoulliNB. Explain your solution.\n",
- "\n",
- "Hint: examine the parameters estimated by the fit() method, theta\\_ and sigma\\_."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 15,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#def P9():\n",
- "\n",
- "### STUDENT END ###\n",
- "\n",
- "\n",
- "### STUDENT END ###\n",
- "\n",
- "#gnb = P9()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "ANSWER:"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "(10) Because Naive Bayes is a generative model, we can use the trained model to generate digits. Train a BernoulliNB model and then generate a 10x20 grid with 20 examples of each digit. Because you're using a Bernoulli model, each pixel output will be either 0 or 1. How do the generated digits compare to the training digits?\n",
- "\n",
- "- You can use np.random.rand() to generate random numbers from a uniform distribution\n",
- "- The estimated probability of each pixel is stored in feature\\_log\\_prob\\_. You'll need to use np.exp() to convert a log probability back to a probability."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 16,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#def P10(num_examples):\n",
- "\n",
- "### STUDENT START ###\n",
- "\n",
- "\n",
- "### STUDENT END ###\n",
- "\n",
- "#P10(20)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "ANSWER:"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "(11) Remember that a strongly calibrated classifier is rougly 90% accurate when the posterior probability of the predicted class is 0.9. A weakly calibrated classifier is more accurate when the posterior is 90% than when it is 80%. A poorly calibrated classifier has no positive correlation between posterior and accuracy.\n",
- "\n",
- "Train a BernoulliNB model with a reasonable alpha value. For each posterior bucket (think of a bin in a histogram), you want to estimate the classifier's accuracy. So for each prediction, find the bucket the maximum posterior belongs to and update the \"correct\" and \"total\" counters.\n",
- "\n",
- "How would you characterize the calibration for the Naive Bayes model?"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 17,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#def P11(buckets, correct, total):\n",
- " \n",
- "### STUDENT START ###\n",
- "\n",
- "\n",
- " \n",
- "### STUDENT END ###\n",
- "\n",
- "#buckets = [0.5, 0.9, 0.999, 0.99999, 0.9999999, 0.999999999, 0.99999999999, 0.9999999999999, 1.0]\n",
- "#correct = [0 for i in buckets]\n",
- "#total = [0 for i in buckets]\n",
- "\n",
- "#P11(buckets, correct, total)\n",
- "\n",
- "#for i in range(len(buckets)):\n",
- "# accuracy = 0.0\n",
- "# if (total[i] > 0): accuracy = correct[i] / total[i]\n",
- "# print 'p(pred) <= %.13f total = %3d accuracy = %.3f' %(buckets[i], total[i], accuracy)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "ANSWER:"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "(12) EXTRA CREDIT\n",
- "\n",
- "Try designing extra features to see if you can improve the performance of Naive Bayes on the dev set. Here are a few ideas to get you started:\n",
- "- Try summing the pixel values in each row and each column.\n",
- "- Try counting the number of enclosed regions; 8 usually has 2 enclosed regions, 9 usually has 1, and 7 usually has 0.\n",
- "\n",
- "Make sure you comment your code well!"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 18,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#def P12():\n",
- "\n",
- "### STUDENT START ###\n",
- "\n",
- "\n",
- "### STUDENT END ###\n",
- "\n",
- "#P12()"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 2",
- "language": "python",
- "name": "python2"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 2
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython2",
- "version": "2.7.6"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}