Update ProgrammingAssignment1.ipynb

eb5d718d · Zeynep Hakguder · 98dcbe39 · eb5d718d
Commit eb5d718d authored 6 years ago by Zeynep Hakguder
--- a/ProgrammingAssignment_1/ProgrammingAssignment1.ipynb
+++ b/ProgrammingAssignment_1/ProgrammingAssignment1.ipynb
@@ -430,14 +430,7 @@
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "Use the cell below to write about your understanding of why *k*-NN performed well if it did or why not if it didn't. What properties of the dataset could have affected the performance of the algorithm?"
+    "Insert a cell below to write about your understanding of why *k*-NN performed well if it did or why not if it didn't. What properties of the dataset could have affected the performance of the algorithm?"
-   ]
-  },
-    {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    ""
   ]
  }
 ],

 %% Cell type:markdown id: tags:
 # *k*-Nearest Neighbor
 We'll implement *k*-Nearest Neighbor (*k*-NN) algorithm for this assignment. We will use the **madelon** dataset as in Programming Assignment 0.
 A skeleton of a general supervised learning model is provided in "model.ipynb". The functions that will be implemented there will be indicated in this notebook.
 ### Assignment Goals:
 In this assignment, we will:
 * implement 'Euclidean' and 'Manhattan' distance metrics
 * use the validation dataset to find a good value for *k*
 * evaluate our model with respect to performance measures:
    * accuracy, generalization error
    * confusion matrix
    *  Receiver Operating Characteristic (ROC) curve
 * try to assess if *k*-NN is suitable for the dataset you used
 ## Note:
 You are not required to follow this exact template. You can change what parameters your functions take or partition the tasks across functions differently. However, make sure there are outputs and implementation for items listed in the rubric for each task. Also, indicate in code with comments which task you are attempting.
 %% Cell type:markdown id: tags:
 # GRADING
 You will be graded on parts that are marked with **TODO** comments. Read the comments in the code to make sure you don't miss any.
 ### Mandatory for 478 & 878:
 |   | Tasks                      | 478 | 878 |
 |---|----------------------------|-----|-----|
 | 1 | Implement `distance`       |  15 |  15 |
 | 2 | Implement `k-NN` methods   |  35 |  30 |
 | 3 | Model evaluation           |  25 |  20 |
 | 5 | ROC curve analysis         |  25 |  25 |
 ### Mandatory for 878, bonus for 478
 |   | Tasks          | 478 | 878 |
 |---|----------------|-----|-----|
 | 4 | Optimizing *k* | 10  | 10  |
 ### Bonus for 478/878
 |   | Tasks          | 478 | 878 |
 |---|----------------|-----|-----|
 | 6 | Assess suitability of *k*-NN | 10  | 10  |
 Points are broken down further below in Rubric sections. The **first** score is for 478, the **second** is for 878 students. There are a total of 100 points in this assignment and extra 20 bonus points for 478 students and 10 bonus points for 878 students.
 %% Cell type:markdown id: tags:
 # YOUR GRADE
 ### Group Members:
 |   | Tasks                      | Points |
 |---|----------------------------|-----|
 | 1 | Implement `distance`       |     |
 | 2 | Implement `k-NN` methods   |     |
 | 3 | Model evaluation           |     |
 | 4 | Optimizing *k*             |     |
 | 5 | ROC curve analysis         |     |
 | 6 | Assess suitability of *k*-NN|    |
 %% Cell type:markdown id: tags:
 You can use numpy for array operations and matplotlib for plotting for this assignment. Please do not add other libraries.
 %% Cell type:code id: tags:
 ``` python
 import numpy as np
 import matplotlib.pyplot as plt
 ```
 %% Cell type:markdown id: tags:
 Following code makes the Model class and relevant functions available from model.ipynb.
 %% Cell type:code id: tags:
 ``` python
 %run 'model.ipynb'
 ```
 %% Cell type:markdown id: tags:
 ## TASK 1: Implement `distance` function
 %% Cell type:markdown id: tags:
 Choice of distance metric plays an important role in the performance of *k*-NN. Let's start with implementing a distance method  in the "distance" function in **model.ipynb**. It should take two data points and the name of the metric and return a scalar value.
 %% Cell type:markdown id: tags:
 ### Rubric:
 * Euclidean +7.5, +7.5
 * Manhattan +7.5, +7.5
 %% Cell type:markdown id: tags:
 ### Test `distance`
 %% Cell type:code id: tags:
 ``` python
 x = np.array(range(100))
 y = np.array(range(100, 200))
 dist_euclidean = distance(x, y, 'Euclidean')
 dist_manhattan = distance(x, y, 'Manhattan')
 print('Euclidean distance: {}, Manhattan distance: {}'.format(dist_euclidean, dist_manhattan))
 ```
 %% Cell type:markdown id: tags:
 ## TASK 2: Implement *k*-NN Class Methods
 %% Cell type:markdown id: tags:
 We can start implementing our *k*-NN classifier. *k*-NN class inherits Model class. Use the "distance" function you defined above. "fit" method takes *k* as an argument. "predict" takes as input an *mxd* array containing *d*-dimensional *m* feature vectors for examples and for each input point outputs the predicted class and the ratio of positive examples in *k* nearest neighbors.
 %% Cell type:markdown id: tags:
 ### Rubric:
 * correct implementation of fit method +10, +10
 * correct implementation of predict method +25, +20
 %% Cell type:code id: tags:
 ``` python
 class kNN(Model):
    '''
    Inherits Model class. Implements the k-NN algorithm for classification.
    '''
    def fit(self, training_features, training_labels, classes, k, distance_f,**kwargs):
        '''
        Fit the model. This is pretty straightforward for k-NN.
        Args:
            training_features: ndarray
            training_labels: ndarray
            classes: ndarray
                1D array containing unique classes in the dataset
            k: int
            distance_f: function
            kwargs: dict
                Contains keyword arguments that will be passed to distance_f
        '''
        # TODO
        # set self.train_features, self.train_labels, self.classes, self.k, self.distance_f, self.distance_metric
        raise NotImplementedError
        return
    def predict(self, test_features):
        '''
        Args:
            test_features: ndarray
                mxd array containing features for the points to be predicted
        Returns:
            preds: ndarray
                mx2 array containing predicted class and proportion for each test point
        '''
        raise NotImplementedError
        # TODO
        # for each point in test_features
        # use your implementation of distance function
        #  distance_f(..., distance_metric)
        # to find the labels of k-nearest neighbors.
        # you'll need proportion of the dominant class
        # in k nearest neighbors
        return preds
 ```
 %% Cell type:markdown id: tags:
 ## TASK 3: Build and Evaluate the Model
 %% Cell type:markdown id: tags:
 ### Rubric:
 * Reasonable accuracy values +10, +5
 * Reasonable confidence intervals on the error estimate +10, +10
 * Reasonable confusion matrix +5, +5
 %% Cell type:markdown id: tags:
 Preprocess the data files and partition the data.
 %% Cell type:code id: tags:
 ``` python
 # initialize the model
 my_model = kNN()
 # obtain features and labels from files
 features, labels = preprocess(feature_file=..., label_file=...)
 # get class names (unique entries in labels)
 classes = np.unique(labels)
 # partition the data set
 val_indices, test_indices, train_indices = partition(size=..., t = 0.3, v = 0.1)
 ```
 %% Cell type:markdown id: tags:
 Assign a value to *k* and fit the *k*-NN model.
 %% Cell type:code id: tags:
 ``` python
 # pass the training features and labels to the fit method
 kwargs_f = {'metric': 'Euclidean'}
 my_model.fit(training_features=..., training_labels-..., classes, k=10, distance_f=..., **kwargs_f)
 ```
 %% Cell type:markdown id: tags:
 ### Computing the confusion matrix for *k* = 10
 Now that we have the true labels and the predicted ones from our model, we can build a confusion matrix and see how accurate our model is. Implement the "conf_matrix" function (in model.ipynb) that takes as input an array of true labels (*true*) and an array of predicted labels (*pred*). It should output a numpy.ndarray. You do not need to change the value of the threshold parameter yet.
 %% Cell type:code id: tags:
 ``` python
 # TODO
 # get model predictions
 pred_ratios = my_model.predict(features[test_indices])
 # For now, we will consider a data point as predicted in a class if more than 0.5
 # of its k-neighbors are in that class.
 threshold = 0.5
 # convert predicted ratios to predicted labels
 pred_labels = None
 # show the distribution of predicted and true labels in a confusion matrix
 confusion = conf_matrix(...)
 confusion
 ```
 %% Cell type:markdown id: tags:
 Evaluate your model on the test data and report your **accuracy**. Also, calculate and report the 95% confidence interval on the generalization **error** estimate.
 %% Cell type:code id: tags:
 ``` python
 # TODO
 # Calculate and report accuracy and generalization error with confidence interval here. Show your work in this cell.
 print('Accuracy: {}'.format(accuracy))
 print('Confidence interval: {}-{}'.format(lower_bound, upper_bound))
 ```
 %% Cell type:markdown id: tags:
 ## TASK 4: Determining *k*
 %% Cell type:markdown id: tags:
 ### Rubric:
 * Accuracies reported with various *k* values +5, +5
 * Confusion matrix for new *k* +5, +5
 %% Cell type:markdown id: tags:
 We can use the validation set to come up with a *k* value that results in better performance in terms of accuracy.
 Below calculate the accuracies for different values of *k* using the validation set. Report a good *k* value and use it in the analyses that follow this section. Report confusion matrix for the new value of *k*.
 %% Cell type:code id: tags:
 ``` python
 # TODO
 # Change values of k.
 # Calculate accuracies for the validation set.
 # Report a good k value.
 # Calculate the confusion matrix for new k.
 ```
 %% Cell type:markdown id: tags:
 ## TASK 5: ROC curve analysis
 * Correct implementation +25, +25
 %% Cell type:markdown id: tags:
 ROC curves are a good way to visualize sensitivity vs. 1-specificity for varying cut off points. Now, implement, in **model.ipynb**, a "ROC" function. "ROC" takes a list containing different threshold values to try and returns two arrays; one where each entry is the sensitivity at a given threshold and the other where entries are 1-specificities.
 %% Cell type:markdown id: tags:
 Use the *k* value you found above, if you completed TASK 4, else use *k* = 10 to plot the ROC curve for values between 0.1 and 1.0.
 %% Cell type:code id: tags:
 ``` python
 # TODO
 # ROC curve
 roc_sens, roc_spec_ = ROC(true_labels=..., preds=..., np.arange(0.1, 1.0, 0.1))
 plt.plot(roc_sens, roc_spec_)
 plt.show()
 ```
 %% Cell type:markdown id: tags:
 ## TASK 6: Assess suitability of *k*-NN to your dataset
 * +10, +10
 %% Cell type:markdown id: tags:
-Use the cell below to write about your understanding of why *k*-NN performed well if it did or why not if it didn't. What properties of the dataset could have affected the performance of the algorithm?
+Insert a cell below to write about your understanding of why *k*-NN performed well if it did or why not if it didn't. What properties of the dataset could have affected the performance of the algorithm?
-%% Cell type:markdown id: tags: