├── README.md ├── datasets └── housing │ └── housing.tgz ├── LICENSE ├── NOTES.md ├── .gitignore ├── ML_Project_Checklist.md └── Ch3_classification.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # Hands-On-ML -------------------------------------------------------------------------------- /datasets/housing/housing.tgz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bexxmodd/Hands-On-ML/main/datasets/housing/housing.tgz -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Beka Modebadze 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /NOTES.md: -------------------------------------------------------------------------------- 1 | # Chapter 1 2 | In a famous 1996 paper, 11 David Wolpert demonstrated that if you 3 | make absolutely no assumption about the data, then there is no reason 4 | to prefer one model over any other. This is called the **No Free Lunch 5 | (NFL)** theorem. 6 | 7 | ----- 8 | # Chapter 2 9 | A sequence of data processing components is called a _data pipeline_. 10 | Pipelines are very common in Machine Learning systems, since there is a 11 | lot of data to manipulate and many data transformations to apply. 12 | Components typically run asynchronously. Each component pulls in a 13 | large amount of data, processes it, and spits out the result in another data 14 | store. Then, some time later, the next component in the pipeline pulls this 15 | data and spits out its own output. Each component is fairly self-contained: 16 | the interface between components is simply the data store. This makes the 17 | system simple to grasp (with the help of a data flow graph), and different 18 | teams can focus on different components. Moreover, if a component 19 | breaks down, the downstream components can often continue to run 20 | normally (at least for a while) by just using the last output from the 21 | broken component. This makes the architecture quite robust. 22 | On the other hand, a broken component can go unnoticed for some time if 23 | proper monitoring is not implemented. The data gets stale and the overall 24 | system’s performance drops. 25 | 26 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | pip-wheel-metadata/ 24 | share/python-wheels/ 25 | *.egg-info/ 26 | .installed.cfg 27 | *.egg 28 | MANIFEST 29 | 30 | # PyInstaller 31 | # Usually these files are written by a python script from a template 32 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 33 | *.manifest 34 | *.spec 35 | 36 | # Installer logs 37 | pip-log.txt 38 | pip-delete-this-directory.txt 39 | 40 | # Unit test / coverage reports 41 | htmlcov/ 42 | .tox/ 43 | .nox/ 44 | .coverage 45 | .coverage.* 46 | .cache 47 | nosetests.xml 48 | coverage.xml 49 | *.cover 50 | *.py,cover 51 | .hypothesis/ 52 | .pytest_cache/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | target/ 76 | 77 | # Jupyter Notebook 78 | .ipynb_checkpoints 79 | 80 | # IPython 81 | profile_default/ 82 | ipython_config.py 83 | 84 | # pyenv 85 | .python-version 86 | 87 | # pipenv 88 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 89 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 90 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 91 | # install all needed dependencies. 92 | #Pipfile.lock 93 | 94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 95 | __pypackages__/ 96 | 97 | # Celery stuff 98 | celerybeat-schedule 99 | celerybeat.pid 100 | 101 | # SageMath parsed files 102 | *.sage.py 103 | 104 | # Environments 105 | .env 106 | .venv 107 | env/ 108 | venv/ 109 | ENV/ 110 | env.bak/ 111 | venv.bak/ 112 | 113 | # Spyder project settings 114 | .spyderproject 115 | .spyproject 116 | 117 | # Rope project settings 118 | .ropeproject 119 | 120 | # mkdocs documentation 121 | /site 122 | 123 | # mypy 124 | .mypy_cache/ 125 | .dmypy.json 126 | dmypy.json 127 | 128 | # Pyre type checker 129 | .pyre/ 130 | -------------------------------------------------------------------------------- /ML_Project_Checklist.md: -------------------------------------------------------------------------------- 1 | This checklist can guide you through your Machine Learning projects. 2 | There are eight main steps: 3 | 4 | 1. Frame the problem and look at the big picture. 5 | 2. Get the data. 6 | 3. Explore the data to gain insights. 7 | 4. Prepare the data to better expose the underlying data patterns to Machine Learning algorithms. 8 | 5. Explore many different models and shortlist the best ones. 9 | 6. Fine-tune your models and combine them into a great solution. 10 | 7. Present your solution. 11 | 8. Launch, monitor, and maintain your system. 12 | 13 | Obviously, you should feel free to adapt this checklist to your needs. 14 | 15 | 16 | ## Frame the Problem and Look at the Big Picture 17 | 18 | 1. Define the objective in business terms. 19 | 2. How will your solution be used? 20 | 3. What are the current solutions/workarounds (if any)? 21 | 4. How should you frame this problem (supervised/unsupervised, online/offline, etc.)? 22 | 5. How should performance be measured? 23 | 6. Is the performance measure aligned with the business objective? 24 | 7. What would be the minimum performance needed to reach the business objective? 25 | 8. What are comparable problems? Can you reuse experience or tools? 26 | 9. Is human expertise available? 27 | 10. How would you solve the problem manually? 28 | 11. List the assumptions you (or others) have made so far. 29 | 12. Verify assumptions if possible. 30 | 31 | 32 | ## Get the Data 33 | Note: automate as much as possible so you can easily get fresh data. 34 | 35 | 1. List the data you need and how much you need. 36 | 2. Find and document where you can get that data. 37 | 3. Check how much space it will take. 38 | 4. Check legal obligations, and get authorization if necessary. 39 | 5. Get access authorizations. 40 | 6. Create a workspace (with enough storage space). 41 | 7. Get the data. 42 | 8. Convert the data to a format you can easily manipulate (without changing the data itself). 43 | 9. Ensure sensitive information is deleted or protected (e.g., anonymized). 44 | 10. Check the size and type of data (time series, sample, geographical, etc.). 45 | 11. Sample a test set, put it aside, and never look at it (no data snooping!). 46 | 47 | 48 | ## Explore the Data 49 | Note: try to get insights from a field expert for these steps. 50 | 51 | 1. Create a copy of the data for exploration (sampling it down to a manageable size if necessary). 52 | 2. Create a Jupyter notebook to keep a record of your data exploration. 53 | 3. Study each attribute and its characteristics: 54 | * Name 55 | * Type (categorical, int/float, bounded/unbounded, text, structured, etc.) 56 | * % of missing values 57 | * Noisiness and type of noise (stochastic, outliers, rounding errors, etc.) 58 | * Usefulness for the task 59 | * Type of distribution (Gaussian, uniform, logarithmic, etc.) 60 | 4. For supervised learning tasks, identify the target attribute(s). 61 | 5. Visualize the data. 62 | 6. Study the correlations between attributes. 63 | 7. Study how you would solve the problem manually.8. Identify the promising transformations you may want to apply. 64 | 9. Identify extra data that would be useful (go back to “Get the Data”). 65 | 10. Document what you have learned. 66 | 67 | 68 | ## Prepare the Data 69 | Notes: 70 | * Work on copies of the data (keep the original dataset intact). 71 | * Write functions for all data transformations you apply, for five reasons: 72 | * So you can easily prepare the data the next time you get a 73 | * fresh dataset 74 | * So you can apply these transformations in future projects 75 | * To clean and prepare the test set 76 | * To clean and prepare new data instances once your solution is live 77 | * To make it easy to treat your preparation choices as hyperparameters 78 | 79 | 1. Data cleaning: 80 | * Fix or remove outliers (optional). 81 | * Fill in missing values (e.g., with zero, mean, median...) or drop their rows (or columns). 82 | 2. Feature selection (optional): 83 | * Drop the attributes that provide no useful information for the task. 84 | 3. Feature engineering, where appropriate: 85 | * Discretize continuous features. 86 | * Decompose features (e.g., categorical, date/time, etc.). 87 | * Add promising transformations of features (e.g., log(x), sqrt(x), x 2 , etc.). 88 | * Aggregate features into promising new features. 89 | 4. Feature scaling: 90 | * Standardize or normalize features. 91 | 92 | 93 | ## Shortlist Promising Models 94 | Notes: 95 | * If the data is huge, you may want to sample smaller training sets so you can train many different models in a reasonable time (be aware that this penalizes complex models such as large neural nets or Random Forests). 96 | * Once again, try to automate these steps as much as possible. 97 | 98 | 1. Train many quick-and-dirty models from different categories (e.g., linear, naive Bayes, SVM, Random Forest, neural net, etc.) using standard parameters. 99 | 2. Measure and compare their performance. For each model, use N-fold cross-validation and compute the mean and standard deviation of the performance measure on the N folds. 100 | 3. Analyze the most significant variables for each algorithm. 101 | 4. Analyze the types of errors the models make.What data would a human have used to avoid these errors? 102 | 5. Perform a quick round of feature selection and engineering. 103 | 6. Perform one or two more quick iterations of the five previous steps. 104 | 7. Shortlist the top three to five most promising models, preferring models that make different types of errors. 105 | 106 | 107 | ## Fine-Tune the System 108 | Notes: 109 | * You will want to use as much data as possible for this step, especially as you move toward the end of fine-tuning. 110 | * As always, automate what you can. 111 | 1. Fine-tune the hyperparameters using cross-validation: 112 | * Treat your data transformation choices as hyperparameters, especially when you are not sure about them (e.g., if you’re not sure whether to replace missing values with zeros or with the median value, or to just drop the rows). 113 | * Unless there are very few hyperparameter values to explore, prefer random search over grid search. If training is very long, you may prefer a Bayesian optimization approach (e.g., using Gaussian process priors, as described by Jasper Snoek et al.). 1 114 | 2. Try Ensemble methods. Combining your best models will often produce better performance than running them individually. 115 | 3. Once you are confident about your final model, measure its performance on the test set to estimate the generalization error. 116 | 117 | _WARNING_ 118 | Don’t tweak your model after measuring the generalization error: you would just 119 | start overfitting the test set. 120 | 121 | 122 | ## Present Your Solution 123 | 124 | 1. Document what you have done. 125 | 2. Create a nice presentation. Make sure you highlight the big picture first. 126 | 3. Explain why your solution achieves the business objective. 127 | 4. Don’t forget to present interesting points you noticed along the way. 128 | * Describe what worked and what did not. 129 | * List your assumptions and your system’s limitations. 130 | 5. Ensure your key findings are communicated through beautiful visualizations or easy-to-remember statements (e.g., “the median income is the number-one predictor of housing prices”). 131 | 132 | 133 | ## Launch! 134 | 1. Get your solution ready for production (plug into production data inputs, write unit tests, etc.). 135 | 2. Write monitoring code to check your system’s live performance at regular intervals and trigger alerts when it drops. 136 | * Beware of slow degradation: models tend to “rot” as data evolves. 137 | * Measuring performance may require a human pipeline (e.g., via a crowdsourcing service). 138 | * Also monitor your inputs’ quality (e.g., a malfunctioning sensor sending random values, or another team’s output becoming stale). This is particularly important for online learning systems. 139 | 3. Retrain your models on a regular basis on fresh data (automate as much as possible). -------------------------------------------------------------------------------- /Ch3_classification.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Chapter 3. Classification\n", 8 | "\n", 9 | "## MNIST\n", 10 | "Scikit-Learn provides many helper functions to download popular datasets. MNIST is one of them, which is a set of 70,000 small images of digits handwritten by high school students and employees of the US Census Bureau. Each image is labeled with the digit it represents." 11 | ] 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": 1, 16 | "metadata": {}, 17 | "outputs": [ 18 | { 19 | "data": { 20 | "text/plain": [ 21 | "dict_keys(['data', 'target', 'frame', 'categories', 'feature_names', 'target_names', 'DESCR', 'details', 'url'])" 22 | ] 23 | }, 24 | "execution_count": 1, 25 | "metadata": {}, 26 | "output_type": "execute_result" 27 | } 28 | ], 29 | "source": [ 30 | "from sklearn.datasets import fetch_openml\n", 31 | "\n", 32 | "mnist = fetch_openml('mnist_784', version=1)\n", 33 | "mnist.keys()" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 2, 39 | "metadata": {}, 40 | "outputs": [ 41 | { 42 | "name": "stdout", 43 | "output_type": "stream", 44 | "text": [ 45 | "X size (70000, 784)\n", 46 | "label size: (70000,)\n" 47 | ] 48 | } 49 | ], 50 | "source": [ 51 | "X, y = mnist['data'], mnist['target']\n", 52 | "print('X size', X.shape)\n", 53 | "print('label size:', y.shape)" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": {}, 59 | "source": [ 60 | "There are 70,000 images, and each image has 784 features. This is because each image is 28 × 28 pixels, and each feature simply represents one pixel’s intensity, from 0 (white) to 255 (black). Let’s take a peek at one digit from the dataset. All you need to do is grab an instance’s feature vector, reshape it to a 28 × 28 array, and display it using Matplotlib’s `imshow()` function:" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": 3, 66 | "metadata": {}, 67 | "outputs": [ 68 | { 69 | "data": { 70 | "image/png": "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\n", 71 | "text/plain": [ 72 | "
" 73 | ] 74 | }, 75 | "metadata": { 76 | "needs_background": "light" 77 | }, 78 | "output_type": "display_data" 79 | } 80 | ], 81 | "source": [ 82 | "import matplotlib as mpl\n", 83 | "import matplotlib.pyplot as plt\n", 84 | "\n", 85 | "some_digit = X.iloc[0].values\n", 86 | "some_digits_image = some_digit.reshape(28, 28)\n", 87 | "\n", 88 | "plt.imshow(some_digits_image, cmap='binary')\n", 89 | "plt.axis(\"off\")\n", 90 | "plt.show()" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": 4, 96 | "metadata": {}, 97 | "outputs": [ 98 | { 99 | "name": "stdout", 100 | "output_type": "stream", 101 | "text": [ 102 | "5\n" 103 | ] 104 | } 105 | ], 106 | "source": [ 107 | "print(y[0])" 108 | ] 109 | }, 110 | { 111 | "cell_type": "code", 112 | "execution_count": 5, 113 | "metadata": {}, 114 | "outputs": [], 115 | "source": [ 116 | "# Let's cast labels as integers\n", 117 | "import numpy as np\n", 118 | "\n", 119 | "y = y.astype(np.uint8)" 120 | ] 121 | }, 122 | { 123 | "cell_type": "markdown", 124 | "metadata": {}, 125 | "source": [ 126 | "The MNIST dataset is actually already split into a training set (the first 60,000 images) and a test set (the last 10,000 images):" 127 | ] 128 | }, 129 | { 130 | "cell_type": "code", 131 | "execution_count": 6, 132 | "metadata": {}, 133 | "outputs": [], 134 | "source": [ 135 | "X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]" 136 | ] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "metadata": {}, 141 | "source": [ 142 | "## Training a Binary Classifier\n", 143 | "\n", 144 | "Let's try to identify only one digit \"5\". This will be an example of _binary classifier_, capable of distibuishing between just two classes, 5 and not-5." 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": 7, 150 | "metadata": {}, 151 | "outputs": [], 152 | "source": [ 153 | "# Set for all 5s\n", 154 | "y_train_5 = (y_train == 5)\n", 155 | "y_test_5 = (y_test == 5)" 156 | ] 157 | }, 158 | { 159 | "cell_type": "markdown", 160 | "metadata": {}, 161 | "source": [ 162 | "Now let’s pick a classifier and train it. A good place to start is with a _Stochastic Gradient Descent (SGD)_ classifier. This classifier deals with large datasets efficiently, because it deals with training instances independetly, one at a time." 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": 8, 168 | "metadata": {}, 169 | "outputs": [ 170 | { 171 | "data": { 172 | "text/plain": [ 173 | "array([ True])" 174 | ] 175 | }, 176 | "execution_count": 8, 177 | "metadata": {}, 178 | "output_type": "execute_result" 179 | } 180 | ], 181 | "source": [ 182 | "from sklearn.linear_model import SGDClassifier\n", 183 | "\n", 184 | "sgd_clf = SGDClassifier(random_state=42)\n", 185 | "sgd_clf.fit(X_train, y_train_5)\n", 186 | "\n", 187 | "# Predicting if the digit is 5\n", 188 | "sgd_clf.predict([some_digit])" 189 | ] 190 | }, 191 | { 192 | "cell_type": "markdown", 193 | "metadata": {}, 194 | "source": [ 195 | "## Performance Measures\n", 196 | "\n", 197 | "### Measuring Accuracy Using Cross-Validation\n", 198 | "Remember that K-fold cross-validation means splitting the training set into K folds (in this case, three), then making predictions and evaluatingthem on each fold using a model trained on the remaining folds." 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": 9, 204 | "metadata": {}, 205 | "outputs": [ 206 | { 207 | "data": { 208 | "text/plain": [ 209 | "array([0.95035, 0.96035, 0.9604 ])" 210 | ] 211 | }, 212 | "execution_count": 9, 213 | "metadata": {}, 214 | "output_type": "execute_result" 215 | } 216 | ], 217 | "source": [ 218 | "from sklearn.model_selection import cross_val_score\n", 219 | "\n", 220 | "cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring='accuracy')" 221 | ] 222 | }, 223 | { 224 | "cell_type": "markdown", 225 | "metadata": {}, 226 | "source": [ 227 | "before we get too excited, let’s look at a very dumb classifier that just classifies every single image in the “not-5” class:" 228 | ] 229 | }, 230 | { 231 | "cell_type": "code", 232 | "execution_count": 10, 233 | "metadata": {}, 234 | "outputs": [ 235 | { 236 | "data": { 237 | "text/plain": [ 238 | "array([0.91125, 0.90855, 0.90915])" 239 | ] 240 | }, 241 | "execution_count": 10, 242 | "metadata": {}, 243 | "output_type": "execute_result" 244 | } 245 | ], 246 | "source": [ 247 | "from sklearn.base import BaseEstimator\n", 248 | "\n", 249 | "class Never5Classifier(BaseEstimator):\n", 250 | " \n", 251 | " def fit(self, X, y=None):\n", 252 | " pass\n", 253 | " \n", 254 | " def predict(self, X):\n", 255 | " return np.zeros((len(X), 1), dtype=bool)\n", 256 | "\n", 257 | "never_5_clf = Never5Classifier()\n", 258 | "cross_val_score(never_5_clf, X_train, y_train_5, cv=3, scoring='accuracy')" 259 | ] 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "metadata": {}, 264 | "source": [ 265 | "That’s right, it has over 90% accuracy! This is simply because only about 10% of the images are 5s, so if you always guess that an image is not a 5, you will be right about 90% of the time.\n", 266 | "\n", 267 | "This demonstrates why accuracy is generally not the preferred performance measure for classifiers, especially when you are dealing with _skewed datasets_.\n", 268 | "\n", 269 | "### Confusion Matrix\n", 270 | "\n", 271 | "The general idea is to count the number of times instances of class A are classified as class B. For example, to know the number of times the classifier confused images of 5s with 3s, you would look in the fifth row and third column of the confusion matrix.\n", 272 | "\n", 273 | "To compute the confusion matrix, you first need to have a set of predictions so that they can be compared to the actual targets. The `cross_val_predict()`\n", 274 | "performs K-fold cross-validation, but instead of returning the evaluation scores, it returns the predictions made on each test fold. This means that you get a clean prediction for each instance in the training set." 275 | ] 276 | }, 277 | { 278 | "cell_type": "code", 279 | "execution_count": 11, 280 | "metadata": {}, 281 | "outputs": [], 282 | "source": [ 283 | "from sklearn.model_selection import cross_val_predict\n", 284 | "\n", 285 | "y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)" 286 | ] 287 | }, 288 | { 289 | "cell_type": "markdown", 290 | "metadata": {}, 291 | "source": [ 292 | "Let's get the confusion matrix and pass the target classes and the predicted classes" 293 | ] 294 | }, 295 | { 296 | "cell_type": "code", 297 | "execution_count": 12, 298 | "metadata": {}, 299 | "outputs": [ 300 | { 301 | "data": { 302 | "text/plain": [ 303 | "array([[53892, 687],\n", 304 | " [ 1891, 3530]])" 305 | ] 306 | }, 307 | "execution_count": 12, 308 | "metadata": {}, 309 | "output_type": "execute_result" 310 | } 311 | ], 312 | "source": [ 313 | "from sklearn.metrics import confusion_matrix\n", 314 | "\n", 315 | "confusion_matrix(y_train_5, y_train_pred)" 316 | ] 317 | }, 318 | { 319 | "cell_type": "markdown", 320 | "metadata": {}, 321 | "source": [ 322 | "Each row in a confusion matrix represents an _actual class_, while each column represents a _predicted class_. The first row of this matrix considers non-5 images (the negative class): 53,892 of them were correctly classified as non-5s (they are called true negatives), while the remaining 687 were wrongly classified as 5s (false positives). The second row considers the images of 5s (the positive class): 1,891 were wrongly classified as non-5s (false negatives), while the remaining 3,530 were correctly classified as 5s (true positives).\n", 323 | "\n", 324 | "An interesting one to look at the accuracy of the positive predictions; this is called the precision of the classifier. _precision_= $\\frac{TP}{TP+FP}$. The $TP$ is the number of true positives, and $FP$ is the number of false positives.\n", 325 | "\n", 326 | "precision is typically used along with another metric named _recall_, also called sensitivity or the true positive rate (TPR): this is the ratio of positive instances that are correctly detected by the classifier. _recall_=$\\frac{TP}{TP+FN}$. $FN$ is the number of false negatives.\n", 327 | "\n", 328 | "### Precision and Recall" 329 | ] 330 | }, 331 | { 332 | "cell_type": "code", 333 | "execution_count": 13, 334 | "metadata": {}, 335 | "outputs": [ 336 | { 337 | "data": { 338 | "text/plain": [ 339 | "0.8370879772350012" 340 | ] 341 | }, 342 | "execution_count": 13, 343 | "metadata": {}, 344 | "output_type": "execute_result" 345 | } 346 | ], 347 | "source": [ 348 | "from sklearn.metrics import precision_score, recall_score\n", 349 | "\n", 350 | "precision_score(y_train_5, y_train_pred)" 351 | ] 352 | }, 353 | { 354 | "cell_type": "code", 355 | "execution_count": 14, 356 | "metadata": {}, 357 | "outputs": [ 358 | { 359 | "data": { 360 | "text/plain": [ 361 | "0.6511713705958311" 362 | ] 363 | }, 364 | "execution_count": 14, 365 | "metadata": {}, 366 | "output_type": "execute_result" 367 | } 368 | ], 369 | "source": [ 370 | "recall_score(y_train_5, y_train_pred)" 371 | ] 372 | }, 373 | { 374 | "cell_type": "markdown", 375 | "metadata": {}, 376 | "source": [ 377 | "It is often convenient to combine precision and recall into a single metric called the $F_1$ score, in particular if you need a simple way to compare two \n", 378 | "classifiers. The $F_1$ score is the harmonic mean of precision and recall. Whereas the regular mean treats all values equally, the harmonic mean gives much more weight to low values.\n", 379 | "\n", 380 | "$F_1 = \\frac{2}{\\frac{1}{precision} + \\frac{1}{recall}}=\\frac{TP}{TP+\\frac{FN+FP}{2}}$" 381 | ] 382 | }, 383 | { 384 | "cell_type": "code", 385 | "execution_count": 15, 386 | "metadata": {}, 387 | "outputs": [ 388 | { 389 | "data": { 390 | "text/plain": [ 391 | "0.7325171197343846" 392 | ] 393 | }, 394 | "execution_count": 15, 395 | "metadata": {}, 396 | "output_type": "execute_result" 397 | } 398 | ], 399 | "source": [ 400 | "from sklearn.metrics import f1_score\n", 401 | "\n", 402 | "f1_score(y_train_5, y_train_pred)" 403 | ] 404 | }, 405 | { 406 | "cell_type": "markdown", 407 | "metadata": {}, 408 | "source": [ 409 | "The $F_1$ score favors classifiers that have similar precision and recall. This\n", 410 | "is not always what you want: in some contexts you mostly care about\n", 411 | "precision, and in other contexts you really care about recall. For example,\n", 412 | "if you trained a classifier to detect videos that are safe for kids, you would\n", 413 | "probably prefer a classifier that rejects many good videos (low recall) but\n", 414 | "keeps only safe ones (high precision), rather than a classifier that has a\n", 415 | "much higher recall but lets a few really bad videos show up in your\n", 416 | "product (in such cases, you may even want to add a human pipeline to\n", 417 | "check the classifier’s video selection). On the other hand, suppose you\n", 418 | "train a classifier to detect shoplifters in surveillance images: it is probably\n", 419 | "fine if your classifier has only 30% precision as long as it has 99% recall\n", 420 | "(sure, the security guards will get a few false alerts, but almost all\n", 421 | "shoplifters will get caught).\n", 422 | "\n", 423 | "Unfortunately, you can’t have it both ways: increasing precision reduces\n", 424 | "recall, and vice versa. This is called the precision/recall trade-off.\n", 425 | "\n", 426 | "How to decide which threshold to use for **SGDClassifier**? First, use the `cross_val_predict()` function to get the scores of all instances in the training set, but this time specify that you want to return decision scores instead of predictions:" 427 | ] 428 | }, 429 | { 430 | "cell_type": "code", 431 | "execution_count": 16, 432 | "metadata": {}, 433 | "outputs": [], 434 | "source": [ 435 | "y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, \n", 436 | " cv=3, method='decision_function')" 437 | ] 438 | }, 439 | { 440 | "cell_type": "markdown", 441 | "metadata": {}, 442 | "source": [ 443 | "compute precision and recall for all possible thresholds:" 444 | ] 445 | }, 446 | { 447 | "cell_type": "code", 448 | "execution_count": 18, 449 | "metadata": {}, 450 | "outputs": [ 451 | { 452 | "data": { 453 | "image/png": "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\n", 454 | "text/plain": [ 455 | "
" 456 | ] 457 | }, 458 | "metadata": { 459 | "needs_background": "light" 460 | }, 461 | "output_type": "display_data" 462 | } 463 | ], 464 | "source": [ 465 | "from sklearn.metrics import precision_recall_curve\n", 466 | "\n", 467 | "precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)\n", 468 | "\n", 469 | "# Plot precision and recall as functions of the threshold value\n", 470 | "def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):\n", 471 | " plt.figure(figsize=(8,4))\n", 472 | " plt.plot(thresholds, precisions[:-1], 'b--', label='Precision')\n", 473 | " plt.plot(thresholds, recalls[:-1], 'g-', label='Recall')\n", 474 | " plt.grid(axis='both')\n", 475 | " plt.legend()\n", 476 | " \n", 477 | "plot_precision_recall_vs_threshold(precisions, recalls, thresholds)\n", 478 | "plt.show()" 479 | ] 480 | }, 481 | { 482 | "cell_type": "markdown", 483 | "metadata": {}, 484 | "source": [ 485 | "Suppose you decide to aim for 90% precision. You look up the first plot\n", 486 | "and find that you need to use a threshold of about 8,000. To be more\n", 487 | "precise you can search for the lowest threshold that gives you at least 90%\n", 488 | "precision ( `np.argmax()` will give you the first index of the maximum\n", 489 | "value, which in this case means the first `True` value)." 490 | ] 491 | }, 492 | { 493 | "cell_type": "code", 494 | "execution_count": 19, 495 | "metadata": {}, 496 | "outputs": [ 497 | { 498 | "name": "stdout", 499 | "output_type": "stream", 500 | "text": [ 501 | "Precision: 0.9000345901072293\n", 502 | "Recall: 0.4799852425751706\n" 503 | ] 504 | } 505 | ], 506 | "source": [ 507 | "threshold_90_precision = thresholds[np.argmax(precisions >= 0.90)]\n", 508 | "\n", 509 | "# Now let's make prediction with this threshold\n", 510 | "y_train_pred_90 = (y_scores >= threshold_90_precision)\n", 511 | "\n", 512 | "print(\"Precision:\", precision_score(y_train_5, y_train_pred_90))\n", 513 | "print(\"Recall:\", recall_score(y_train_5, y_train_pred_90))" 514 | ] 515 | }, 516 | { 517 | "cell_type": "markdown", 518 | "metadata": {}, 519 | "source": [ 520 | "A high-precision classifier is not very useful if its recall is too low!\n", 521 | "\n", 522 | "### The ROC Curve\n", 523 | "The _receiver operating characteristic (ROC)_ curve is another common\n", 524 | "tool used with binary classifiers. It is very similar to the precision/recall\n", 525 | "curve, but instead of plotting precision versus recall, the ROC curve plots\n", 526 | "the true positive rate (another name for recall) against the false positive\n", 527 | "rate (FPR). The FPR is the ratio of negative instances that are incorrectly\n", 528 | "classified as positive. It is equal to 1 – the true negative rate (TNR), which\n", 529 | "is the ratio of negative instances that are correctly classified as negative.\n", 530 | "The TNR is also called specificity. Hence, the ROC curve plots sensitivity\n", 531 | "(recall) versus 1 – specificity" 532 | ] 533 | }, 534 | { 535 | "cell_type": "code", 536 | "execution_count": 20, 537 | "metadata": {}, 538 | "outputs": [ 539 | { 540 | "data": { 541 | "image/png": "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\n", 542 | "text/plain": [ 543 | "
" 544 | ] 545 | }, 546 | "metadata": { 547 | "needs_background": "light" 548 | }, 549 | "output_type": "display_data" 550 | } 551 | ], 552 | "source": [ 553 | "from sklearn.metrics import roc_curve\n", 554 | "\n", 555 | "fpr, tpr, thresholds = roc_curve(y_train_5, y_scores)\n", 556 | "\n", 557 | "# Plot FPR against the TPR\n", 558 | "def plot_roc_curve(fpr, tpr, label=None):\n", 559 | " \"\"\"Plots ROC Curve (FPR agains TPR)\"\"\"\n", 560 | " plt.figure(figsize=(5, 5))\n", 561 | " plt.plot(fpr, tpr, linewidth=3, label=label)\n", 562 | " plt.plot([0, 1], [0, 1], 'k--')\n", 563 | " plt.grid(axis='both')\n", 564 | " plt.ylabel('True Positive Rate (Recall)')\n", 565 | " plt.xlabel('False Positive Rate')\n", 566 | " plt.ylim(0, 1)\n", 567 | " plt.xlim(0, 1)\n", 568 | " \n", 569 | "plot_roc_curve(fpr, tpr)\n", 570 | "plt.show()" 571 | ] 572 | }, 573 | { 574 | "cell_type": "markdown", 575 | "metadata": {}, 576 | "source": [ 577 | "One way to compare classifiers is to measure the area under the curve\n", 578 | "(AUC). A perfect classifier will have a ROC AUC equal to 1, whereas a\n", 579 | "purely random classifier will have a ROC AUC equal to 0.5. Scikit-Learn\n", 580 | "provides a function to compute the ROC AUC:" 581 | ] 582 | }, 583 | { 584 | "cell_type": "code", 585 | "execution_count": 21, 586 | "metadata": {}, 587 | "outputs": [ 588 | { 589 | "name": "stdout", 590 | "output_type": "stream", 591 | "text": [ 592 | "ROC AUC Score: 0.9604938554008616\n" 593 | ] 594 | } 595 | ], 596 | "source": [ 597 | "from sklearn.metrics import roc_auc_score\n", 598 | "\n", 599 | "print('ROC AUC Score:', roc_auc_score(y_train_5, y_scores))" 600 | ] 601 | }, 602 | { 603 | "cell_type": "markdown", 604 | "metadata": {}, 605 | "source": [ 606 | "As a rule of thumb, you should prefer the PR curve\n", 607 | "whenever the positive class is rare or when you care more about the false positives\n", 608 | "than the false negatives. Otherwise, use the ROC curve." 609 | ] 610 | }, 611 | { 612 | "cell_type": "code", 613 | "execution_count": 22, 614 | "metadata": {}, 615 | "outputs": [], 616 | "source": [ 617 | "# Let's train random forest model\n", 618 | "from sklearn.ensemble import RandomForestClassifier\n", 619 | "\n", 620 | "forest_clf = RandomForestClassifier(random_state=42)\n", 621 | "y_probas_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3, \n", 622 | " method='predict_proba')" 623 | ] 624 | }, 625 | { 626 | "cell_type": "code", 627 | "execution_count": 23, 628 | "metadata": {}, 629 | "outputs": [ 630 | { 631 | "data": { 632 | "image/png": "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\n", 633 | "text/plain": [ 634 | "
" 635 | ] 636 | }, 637 | "metadata": { 638 | "needs_background": "light" 639 | }, 640 | "output_type": "display_data" 641 | } 642 | ], 643 | "source": [ 644 | "# The roc_curve() function expects labels and scores, \n", 645 | "# but instead of scores you can give it class probabilities\n", 646 | "y_scores_forest = y_probas_forest[:, 1] # score = proba of positive class\n", 647 | "fpr_forest, tpr_forest, thresholds_forest = roc_curve(y_train_5,y_scores_forest)\n", 648 | "\n", 649 | "plot_roc_curve(fpr_forest, tpr_forest, \"Random Forest\")" 650 | ] 651 | }, 652 | { 653 | "cell_type": "code", 654 | "execution_count": 24, 655 | "metadata": {}, 656 | "outputs": [ 657 | { 658 | "name": "stdout", 659 | "output_type": "stream", 660 | "text": [ 661 | "ROC AUC score: 0.9983436731328145\n" 662 | ] 663 | } 664 | ], 665 | "source": [ 666 | "print('ROC AUC score:', roc_auc_score(y_train_5, y_scores_forest))" 667 | ] 668 | }, 669 | { 670 | "cell_type": "markdown", 671 | "metadata": {}, 672 | "source": [ 673 | "You now know how to train binary classifiers, choose the appropriate\n", 674 | "metric for your task, evaluate your classifiers using cross-validation,\n", 675 | "select the precision/recall trade-off that fits your needs, and use ROC\n", 676 | "curves and ROC AUC scores to compare various models.\n", 677 | "\n", 678 | "## Multiclass Classification\n", 679 | "_Multinomial classifier_ distinguishes between more than two classes. Even though some algorithms only perform binary classifications, there are ways to still use them for multiple classes classification. One way is to create a system that classifies 10 different type images by taking one class at a time and classifying it against the rest. This is called _one-versus-rest_ (OvR) strategy. Another strategy is to train a binary classifier for every pair of classes: distinguish between 0 and 1 class, then between 0 and 2, then between 0 and 3 and so on. This is called _one-versus-one_ (OvO) strategy. For $N$ classes you need to train $\\frac{N\\times (N-1)}{2}$ classifiers.\n", 680 | "\n", 681 | "Scikit-Learn detects when you try to use a binary classification algorithm for a multiclass classification task, and it automatically runs OvR or OvO, depending on the algorithm:" 682 | ] 683 | }, 684 | { 685 | "cell_type": "code", 686 | "execution_count": 25, 687 | "metadata": {}, 688 | "outputs": [ 689 | { 690 | "data": { 691 | "text/plain": [ 692 | "array([5], dtype=uint8)" 693 | ] 694 | }, 695 | "execution_count": 25, 696 | "metadata": {}, 697 | "output_type": "execute_result" 698 | } 699 | ], 700 | "source": [ 701 | "from sklearn.svm import SVC\n", 702 | "\n", 703 | "svm_clf = SVC()\n", 704 | "svm_clf.fit(X_train, y_train)\n", 705 | "svm_clf.predict([some_digit])" 706 | ] 707 | }, 708 | { 709 | "cell_type": "markdown", 710 | "metadata": {}, 711 | "source": [ 712 | "This code trains the SVC on the training set using the original target classes from 0 to 9 ( y_train ), instead of the 5-versus-the-rest target classes ( y_train_5 )" 713 | ] 714 | }, 715 | { 716 | "cell_type": "code", 717 | "execution_count": 26, 718 | "metadata": {}, 719 | "outputs": [ 720 | { 721 | "data": { 722 | "text/plain": [ 723 | "array([[ 1.72501977, 2.72809088, 7.2510018 , 8.3076379 , -0.31087254,\n", 724 | " 9.3132482 , 1.70975103, 2.76765202, 6.23049537, 4.84771048]])" 725 | ] 726 | }, 727 | "execution_count": 26, 728 | "metadata": {}, 729 | "output_type": "execute_result" 730 | } 731 | ], 732 | "source": [ 733 | "# This will return 10 scores per instance\n", 734 | "some_digit_scores = svm_clf.decision_function([some_digit])\n", 735 | "some_digit_scores" 736 | ] 737 | }, 738 | { 739 | "cell_type": "code", 740 | "execution_count": 27, 741 | "metadata": {}, 742 | "outputs": [ 743 | { 744 | "data": { 745 | "text/plain": [ 746 | "5" 747 | ] 748 | }, 749 | "execution_count": 27, 750 | "metadata": {}, 751 | "output_type": "execute_result" 752 | } 753 | ], 754 | "source": [ 755 | "# Highest score is the one corresponding to class 5\n", 756 | "np.argmax(some_digit_scores)" 757 | ] 758 | }, 759 | { 760 | "cell_type": "code", 761 | "execution_count": 28, 762 | "metadata": {}, 763 | "outputs": [ 764 | { 765 | "data": { 766 | "text/plain": [ 767 | "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8)" 768 | ] 769 | }, 770 | "execution_count": 28, 771 | "metadata": {}, 772 | "output_type": "execute_result" 773 | } 774 | ], 775 | "source": [ 776 | "svm_clf.classes_" 777 | ] 778 | }, 779 | { 780 | "cell_type": "code", 781 | "execution_count": 29, 782 | "metadata": {}, 783 | "outputs": [ 784 | { 785 | "data": { 786 | "text/plain": [ 787 | "5" 788 | ] 789 | }, 790 | "execution_count": 29, 791 | "metadata": {}, 792 | "output_type": "execute_result" 793 | } 794 | ], 795 | "source": [ 796 | "svm_clf.classes_[5]" 797 | ] 798 | }, 799 | { 800 | "cell_type": "markdown", 801 | "metadata": {}, 802 | "source": [ 803 | "**WARNING**: When a classifier is trained, it stores the list of target classes in its `classes_` attribute, ordered by value.\n", 804 | "\n", 805 | "If you want to force Scikit-Learn to use _one-versus-one_ or _one-versus-the-rest_, you can use the `OneVsOneClassifier` or `OneVsRestClassifier` classes" 806 | ] 807 | }, 808 | { 809 | "cell_type": "code", 810 | "execution_count": 30, 811 | "metadata": {}, 812 | "outputs": [ 813 | { 814 | "data": { 815 | "text/plain": [ 816 | "array([5], dtype=uint8)" 817 | ] 818 | }, 819 | "execution_count": 30, 820 | "metadata": {}, 821 | "output_type": "execute_result" 822 | } 823 | ], 824 | "source": [ 825 | "# Classify using OvR\n", 826 | "from sklearn.multiclass import OneVsRestClassifier\n", 827 | "\n", 828 | "ovr_clf = OneVsRestClassifier(SVC())\n", 829 | "ovr_clf.fit(X_train, y_train)\n", 830 | "ovr_clf.predict([some_digit])" 831 | ] 832 | }, 833 | { 834 | "cell_type": "code", 835 | "execution_count": 31, 836 | "metadata": {}, 837 | "outputs": [ 838 | { 839 | "data": { 840 | "text/plain": [ 841 | "10" 842 | ] 843 | }, 844 | "execution_count": 31, 845 | "metadata": {}, 846 | "output_type": "execute_result" 847 | } 848 | ], 849 | "source": [ 850 | "len(ovr_clf.estimators_)" 851 | ] 852 | }, 853 | { 854 | "cell_type": "code", 855 | "execution_count": 32, 856 | "metadata": {}, 857 | "outputs": [ 858 | { 859 | "data": { 860 | "text/plain": [ 861 | "array([3], dtype=uint8)" 862 | ] 863 | }, 864 | "execution_count": 32, 865 | "metadata": {}, 866 | "output_type": "execute_result" 867 | } 868 | ], 869 | "source": [ 870 | "# Trying SGD Classifier. No need for OvR or OvO as\n", 871 | "# SGD directly classifies into multiple classes.\n", 872 | "sgd_clf.fit(X_train, y_train)\n", 873 | "sgd_clf.predict([some_digit])" 874 | ] 875 | }, 876 | { 877 | "cell_type": "code", 878 | "execution_count": 33, 879 | "metadata": {}, 880 | "outputs": [ 881 | { 882 | "data": { 883 | "text/plain": [ 884 | "array([[-31893.03095419, -34419.69069632, -9530.63950739,\n", 885 | " 1823.73154031, -22320.14822878, -1385.80478895,\n", 886 | " -26188.91070951, -16147.51323997, -4604.35491274,\n", 887 | " -12050.767298 ]])" 888 | ] 889 | }, 890 | "execution_count": 33, 891 | "metadata": {}, 892 | "output_type": "execute_result" 893 | } 894 | ], 895 | "source": [ 896 | "sgd_clf.decision_function([some_digit])" 897 | ] 898 | }, 899 | { 900 | "cell_type": "markdown", 901 | "metadata": {}, 902 | "source": [ 903 | "You can see that the classifier is fairly confident about its prediction: almost all scores are largely negative, while class 5 has a score of ...\n", 904 | "\n", 905 | "You can evaluate this classifier using `cros_val_score()`." 906 | ] 907 | }, 908 | { 909 | "cell_type": "code", 910 | "execution_count": 34, 911 | "metadata": {}, 912 | "outputs": [ 913 | { 914 | "data": { 915 | "text/plain": [ 916 | "array([0.87365, 0.85835, 0.8689 ])" 917 | ] 918 | }, 919 | "execution_count": 34, 920 | "metadata": {}, 921 | "output_type": "execute_result" 922 | } 923 | ], 924 | "source": [ 925 | "cross_val_score(sgd_clf, X_train, y_train,\n", 926 | " cv=3, scoring=\"accuracy\")" 927 | ] 928 | }, 929 | { 930 | "cell_type": "markdown", 931 | "metadata": {}, 932 | "source": [ 933 | "We get 86% on all test folds. If we used a random classifier we would get 10%. We still can get a better score by scaling the inputs:" 934 | ] 935 | }, 936 | { 937 | "cell_type": "code", 938 | "execution_count": 35, 939 | "metadata": {}, 940 | "outputs": [ 941 | { 942 | "data": { 943 | "text/plain": [ 944 | "array([0.8983, 0.891 , 0.9018])" 945 | ] 946 | }, 947 | "execution_count": 35, 948 | "metadata": {}, 949 | "output_type": "execute_result" 950 | } 951 | ], 952 | "source": [ 953 | "from sklearn.preprocessing import StandardScaler\n", 954 | "\n", 955 | "scaler = StandardScaler()\n", 956 | "X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))\n", 957 | "cross_val_score(sgd_clf, X_train_scaled, y_train, cv=3, scoring='accuracy')" 958 | ] 959 | }, 960 | { 961 | "cell_type": "markdown", 962 | "metadata": {}, 963 | "source": [ 964 | "## Error Analysis\n", 965 | "\n", 966 | "One way to improve selected model is to analyze the types of errors it makes." 967 | ] 968 | }, 969 | { 970 | "cell_type": "code", 971 | "execution_count": 37, 972 | "metadata": {}, 973 | "outputs": [ 974 | { 975 | "name": "stdout", 976 | "output_type": "stream", 977 | "text": [ 978 | "[[5577 0 22 5 8 43 36 6 225 1]\n", 979 | " [ 0 6400 37 24 4 44 4 7 212 10]\n", 980 | " [ 27 27 5220 92 73 27 67 36 378 11]\n", 981 | " [ 22 17 117 5227 2 203 27 40 403 73]\n", 982 | " [ 12 14 41 9 5182 12 34 27 347 164]\n", 983 | " [ 27 15 30 168 53 4444 75 14 535 60]\n", 984 | " [ 30 15 42 3 44 97 5552 3 131 1]\n", 985 | " [ 21 10 51 30 49 12 3 5684 195 210]\n", 986 | " [ 17 63 48 86 3 126 25 10 5429 44]\n", 987 | " [ 25 18 30 64 118 36 1 179 371 5107]]\n" 988 | ] 989 | } 990 | ], 991 | "source": [ 992 | "# Let's look at the confusion matrix\n", 993 | "y_train_pred = cross_val_predict(sgd_clf, X_train_scaled, y_train, cv=3)\n", 994 | "conf_mx = confusion_matrix(y_train, y_train_pred)\n", 995 | "print(conf_mx)" 996 | ] 997 | }, 998 | { 999 | "cell_type": "code", 1000 | "execution_count": 61, 1001 | "metadata": {}, 1002 | "outputs": [ 1003 | { 1004 | "data": { 1005 | "image/png": "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\n", 1006 | "text/plain": [ 1007 | "
" 1008 | ] 1009 | }, 1010 | "metadata": { 1011 | "needs_background": "light" 1012 | }, 1013 | "output_type": "display_data" 1014 | } 1015 | ], 1016 | "source": [ 1017 | "# Let's look ath the image of the confusion matrix\n", 1018 | "plt.matshow(conf_mx, cmap=plt.cm.gray)\n", 1019 | "plt.show()" 1020 | ] 1021 | }, 1022 | { 1023 | "cell_type": "markdown", 1024 | "metadata": {}, 1025 | "source": [ 1026 | "The 5s look slightly darker than the other digits, which could mean that there are\n", 1027 | "fewer images of 5s in the dataset or that the classifier does not perform as\n", 1028 | "well on 5s as on other digits. In fact, you can verify that both are the case.\n", 1029 | "\n", 1030 | "Let’s focus the plot on the errors. First, you need to divide each value in\n", 1031 | "the confusion matrix by the number of images in the corresponding class\n", 1032 | "so that you can compare error rates instead of absolute numbers of errors:" 1033 | ] 1034 | }, 1035 | { 1036 | "cell_type": "code", 1037 | "execution_count": 60, 1038 | "metadata": {}, 1039 | "outputs": [ 1040 | { 1041 | "data": { 1042 | "image/png": "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\n", 1043 | "text/plain": [ 1044 | "
" 1045 | ] 1046 | }, 1047 | "metadata": { 1048 | "needs_background": "light" 1049 | }, 1050 | "output_type": "display_data" 1051 | } 1052 | ], 1053 | "source": [ 1054 | "row_sums = conf_mx.sum(axis=1, keepdims=True)\n", 1055 | "norm_conf_mx = conf_mx / row_sums\n", 1056 | "\n", 1057 | "np.fill_diagonal(norm_conf_mx, 0)\n", 1058 | "plt.matshow(norm_conf_mx, cmap=plt.cm.gray)\n", 1059 | "plt.show()" 1060 | ] 1061 | }, 1062 | { 1063 | "cell_type": "markdown", 1064 | "metadata": {}, 1065 | "source": [ 1066 | "Analyzing individual errors can also be a good way to gain insights on\n", 1067 | "what your classifier is doing and why it is failing, but it is more difficult\n", 1068 | "and time-consuming. For example, let's ploit 3s and 5s:" 1069 | ] 1070 | }, 1071 | { 1072 | "cell_type": "code", 1073 | "execution_count": 78, 1074 | "metadata": {}, 1075 | "outputs": [], 1076 | "source": [ 1077 | "def plot_digits(instances, images_per_row=10, **options):\n", 1078 | " \"\"\"\n", 1079 | " Plots digit with a grid form - correctly & incorrecly guessed\n", 1080 | " \"\"\"\n", 1081 | " size = 28\n", 1082 | " images_per_row = min(len(instances), images_per_row)\n", 1083 | " images = [instance.reshape(size,size) for instance in instances.values]\n", 1084 | " n_rows = (len(instances) - 1) // images_per_row + 1\n", 1085 | " row_images = []\n", 1086 | " n_empty = n_rows * images_per_row - len(instances)\n", 1087 | " images.append(np.zeros((size, size * n_empty)))\n", 1088 | " for row in range(n_rows):\n", 1089 | " rimages = images[row * images_per_row : (row + 1) * images_per_row]\n", 1090 | " row_images.append(np.concatenate(rimages, axis=1))\n", 1091 | " image = np.concatenate(row_images, axis=0)\n", 1092 | " plt.imshow(image, cmap = mpl.cm.binary, **options)\n", 1093 | " plt.axis(\"off\")" 1094 | ] 1095 | }, 1096 | { 1097 | "cell_type": "code", 1098 | "execution_count": 79, 1099 | "metadata": {}, 1100 | "outputs": [ 1101 | { 1102 | "data": { 1103 | "image/png": "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\n", 1104 | "text/plain": [ 1105 | "
" 1106 | ] 1107 | }, 1108 | "metadata": { 1109 | "needs_background": "light" 1110 | }, 1111 | "output_type": "display_data" 1112 | } 1113 | ], 1114 | "source": [ 1115 | "cl_a, cl_b = 3, 5\n", 1116 | "X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)]\n", 1117 | "X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_a)]\n", 1118 | "X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_b)]\n", 1119 | "X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_b)]\n", 1120 | "\n", 1121 | "plt.figure(figsize=(8,8))\n", 1122 | "plt.subplot(221); plot_digits(X_aa[:25], images_per_row=5)\n", 1123 | "plt.subplot(222); plot_digits(X_ab[:25], images_per_row=5)\n", 1124 | "plt.subplot(223); plot_digits(X_ba[:25], images_per_row=5)\n", 1125 | "plt.subplot(224); plot_digits(X_bb[:25], images_per_row=5)\n", 1126 | "plt.show()" 1127 | ] 1128 | }, 1129 | { 1130 | "cell_type": "markdown", 1131 | "metadata": {}, 1132 | "source": [ 1133 | "Most misclassified images seem like obvious errors to us, and it’s hard to understand why the classifier made the mistakes it did. 3 The reason is that we used a simple `SGDClassifier`, which is a linear model. All it does is assign a weight per class to each pixel, and when it sees a new image it just sums up the weighted pixelintensities to get a score for each class. So since 3s and 5s differ only by a few pixels, this model will easily confuse them.\n", 1134 | "\n", 1135 | "The main difference between 3s and 5s is the position of the small line that joins the top line to the bottom arc. If you draw a 3 with the junction\n", 1136 | "slightly shifted to the left, the classifier might classify it as a 5, and vice versa. In other words, this classifier is quite sensitive to image shifting and rotation. So one way to reduce the 3/5 confusion would be to preprocess the images to ensure that they are well centered and not too rotated. This will probably help reduce other errors as well.\n", 1137 | "\n", 1138 | "## Multilabel Classification\n", 1139 | "\n", 1140 | "Say the classifier has been trained to recognize three faces, Alice, Bob, and Charlie. Then when the classifier is shown a picture of Alice and Charlie, it should output [1, 0, 1] (meaning “Alice yes, Bob no, Charlie yes”). Such a classification system that outputs multiple binary tags is called _a multilabel classification_ system." 1141 | ] 1142 | }, 1143 | { 1144 | "cell_type": "code", 1145 | "execution_count": 81, 1146 | "metadata": {}, 1147 | "outputs": [ 1148 | { 1149 | "data": { 1150 | "text/plain": [ 1151 | "KNeighborsClassifier()" 1152 | ] 1153 | }, 1154 | "execution_count": 81, 1155 | "metadata": {}, 1156 | "output_type": "execute_result" 1157 | } 1158 | ], 1159 | "source": [ 1160 | "from sklearn.neighbors import KNeighborsClassifier\n", 1161 | "\n", 1162 | "y_train_large = (y_train >= 7)\n", 1163 | "y_train_odd = (y_train % 2 == 1)\n", 1164 | "y_multilabel = np.c_[y_train_large, y_train_odd]\n", 1165 | "\n", 1166 | "knn_clf = KNeighborsClassifier()\n", 1167 | "knn_clf.fit(X_train, y_multilabel)" 1168 | ] 1169 | }, 1170 | { 1171 | "cell_type": "markdown", 1172 | "metadata": {}, 1173 | "source": [ 1174 | "This code creates a y_multilabel array containing two target labels for each digit image: the first indicates whether or not the digit is large (7, 8,or 9), and the second indicates whether or not it is odd." 1175 | ] 1176 | }, 1177 | { 1178 | "cell_type": "code", 1179 | "execution_count": 83, 1180 | "metadata": {}, 1181 | "outputs": [ 1182 | { 1183 | "data": { 1184 | "text/plain": [ 1185 | "array([[False, True]])" 1186 | ] 1187 | }, 1188 | "execution_count": 83, 1189 | "metadata": {}, 1190 | "output_type": "execute_result" 1191 | } 1192 | ], 1193 | "source": [ 1194 | "# Prediction with Multilabel classifier\n", 1195 | "knn_clf.predict([some_digit])" 1196 | ] 1197 | }, 1198 | { 1199 | "cell_type": "markdown", 1200 | "metadata": {}, 1201 | "source": [ 1202 | "And it gets it right! The digit 5 is indeed not large ( False ) and odd ( True ).\n", 1203 | "\n", 1204 | "One approach to evaluate multilable classifier is to measure $F_1$ score for each individual label, then compare the average score." 1205 | ] 1206 | }, 1207 | { 1208 | "cell_type": "code", 1209 | "execution_count": 85, 1210 | "metadata": {}, 1211 | "outputs": [ 1212 | { 1213 | "data": { 1214 | "text/plain": [ 1215 | "0.976410265560605" 1216 | ] 1217 | }, 1218 | "execution_count": 85, 1219 | "metadata": {}, 1220 | "output_type": "execute_result" 1221 | } 1222 | ], 1223 | "source": [ 1224 | "y_train_knn_pred = cross_val_predict(knn_clf, X_train, y_multilabel, cv=3)\n", 1225 | "f1_score(y_multilabel, y_train_knn_pred, average='macro')" 1226 | ] 1227 | }, 1228 | { 1229 | "cell_type": "markdown", 1230 | "metadata": {}, 1231 | "source": [ 1232 | "If for example we have many more pictures of Alice then of Bob or Charlie, you may want to give more weight to the classifier's score on picture of Alice. Simple option is to give each label a weight equal to its support. This can be done by setting `average=\"weighted\"`.\n", 1233 | "\n", 1234 | "## Multioutput Classification\n", 1235 | "\n", 1236 | "Multiclass or multioutput classification can have more than two possible values.\n", 1237 | "\n", 1238 | "Let's first build a system that removes noise from images. The classifier's output is multilabel (one label per pixel) and each label can have multiple values (pixel intensity ranges from 0 to 255)." 1239 | ] 1240 | }, 1241 | { 1242 | "cell_type": "code", 1243 | "execution_count": 94, 1244 | "metadata": {}, 1245 | "outputs": [], 1246 | "source": [ 1247 | "noise = np.random.randint(0, 100, (len(X_train), 784))\n", 1248 | "X_train_mod = X_train + noise\n", 1249 | "noise = np.random.randint(0, 100, (len(X_test), 784))\n", 1250 | "X_test_mod = X_test + noise\n", 1251 | "y_train_mod = X_train\n", 1252 | "y_test_mod = X_test" 1253 | ] 1254 | }, 1255 | { 1256 | "cell_type": "code", 1257 | "execution_count": 98, 1258 | "metadata": {}, 1259 | "outputs": [ 1260 | { 1261 | "data": { 1262 | "image/png": "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\n", 1263 | "text/plain": [ 1264 | "
" 1265 | ] 1266 | }, 1267 | "metadata": { 1268 | "needs_background": "light" 1269 | }, 1270 | "output_type": "display_data" 1271 | } 1272 | ], 1273 | "source": [ 1274 | "def plot_digit(data):\n", 1275 | " image = data.reshape(28, 28)\n", 1276 | " plt.imshow(image, cmap = mpl.cm.binary,\n", 1277 | " interpolation=\"nearest\")\n", 1278 | " plt.axis(\"off\")\n", 1279 | " \n", 1280 | "# Let's take a look at the example\n", 1281 | "some_index = 0\n", 1282 | "plt.subplot(121); plot_digit(X_test_mod.iloc[some_index].values)\n", 1283 | "plt.subplot(122); plot_digit(y_test_mod.iloc[some_index].values)\n", 1284 | "plt.show()" 1285 | ] 1286 | }, 1287 | { 1288 | "cell_type": "code", 1289 | "execution_count": 101, 1290 | "metadata": {}, 1291 | "outputs": [ 1292 | { 1293 | "data": { 1294 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAFO0lEQVR4nO3dsUvUfxzH8TtzaG27QW0pCAKhqTYdHSIapMnVoqV/QVysPyBy9H9Q0EEImoKGtkDczEHbCpxEvN/2g8B7f/X0utedj8fom+/dh+jpB/zwuWt3u90WkGdi2AsALiZOCCVOCCVOCCVOCDXZMPenXBi89kU/tHNCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCKHFCqMlhL2BQ2u12z9nKykr57IMHD8r59PR0OZ+bmyvncBl2TgglTgglTgglTgglTgglTgglTgjV7na71bwcJnv37l3P2cePH8tnG/5Nru3t27c9Z0+fPi2f7XQ613rv4+Pjcv7ly5ees4ODg/LZ79+/l/MPHz6U8zdv3pTzMXbhobydE0KJE0KJE0KJE0KJE0KJE0KJE0KN7Tln5cWLF+X88ePH5fzHjx/lfGtrq5xXd00HfcZavfeg37/pvT9//txzNj8/f8OrieKcE0aJOCGUOCGUOCGUOCGUOCGUOCHU2H5ubWVzc3PYSxhJZ2dn5fz169flfGNjo5yfnJxceU3jzM4JocQJocQJocQJocQJocQJocQJoW7lOSf9mZys/7s0nVM23efkb3ZOCCVOCCVOCCVOCCVOCCVOCHUrPxqTwbhz5045f/jwYTnf29u7yeWMEh+NCaNEnBBKnBBKnBBKnBBKnBBKnBDKlTEu7du3b+X8/Py8nC8uLt7kcsaenRNCiRNCiRNCiRNCiRNCiRNCiRNCuc/JpS0tLZXzpnPQ3d3dcn7//v0rr2lMuM8Jo0ScEEqcEEqcEEqcEEqcEEqcEMp9Tv4yMdH/7+u1tbVyfovPMfti54RQ4oRQ4oRQ4oRQ4oRQ4oRQ4oRQ7nPeMqenp+W8Oos8Pj4unz06OirnnU6nnN9i7nPCKBEnhBInhBInhBInhBInhHJlbMw0HZXcvXu3nFdHa+vr6+Wzjkpulp0TQokTQokTQokTQokTQokTQokTQjnnHDP7+/vlvOGKYOvevXs9Z8+fP+9rTfTHzgmhxAmhxAmhxAmhxAmhxAmhxAmhnHOOmJ8/f5bz2dnZa73++/fve86mpqau9dpcjZ0TQokTQokTQokTQokTQokTQokTQjnnDHN+fl7O19bWynnTfc1Hjx6V81evXpVz/h07J4QSJ4QSJ4QSJ4QSJ4QSJ4RqN/zpvf67PDfu8PCwnM/MzFzr9Xd2dsr5wsLCtV6fvrQv+qGdE0KJE0KJE0KJE0KJE0KJE0KJE0I55wxTfQVfq9Vq/f79u5w/e/asnH/9+vWqS2LwnHPCKBEnhBInhBInhBInhBInhBInhPLRmEPw69evnrM/f/6Uz7bbFx6J/e/Tp099rYk8dk4IJU4IJU4IJU4IJU4IJU4IJU4I5ZxzCDqdTs9Z0znm6upqOX/y5ElfayKPnRNCiRNCiRNCiRNCiRNCiRNCiRNC+dzaIZiY6P07sen7Mbe3t296OQyfz62FUSJOCCVOCCVOCCVOCCVOCOXK2BAsLy/3nL18+fLfLYRodk4IJU4IJU4IJU4IJU4IJU4IJU4I5coYDJ8rYzBKxAmhxAmhxAmhxAmhxAmhxAmhmu5z1t9HBwyMnRNCiRNCiRNCiRNCiRNCiRNC/QfJN7COt705zQAAAABJRU5ErkJggg==\n", 1295 | "text/plain": [ 1296 | "
" 1297 | ] 1298 | }, 1299 | "metadata": { 1300 | "needs_background": "light" 1301 | }, 1302 | "output_type": "display_data" 1303 | } 1304 | ], 1305 | "source": [ 1306 | "# Let's run the classifier\n", 1307 | "knn_clf.fit(X_train_mod, y_train_mod)\n", 1308 | "clean_digit = knn_clf.predict([X_test_mod.iloc[some_index].values])\n", 1309 | "plot_digit(clean_digit)" 1310 | ] 1311 | }, 1312 | { 1313 | "cell_type": "markdown", 1314 | "metadata": {}, 1315 | "source": [ 1316 | "Looks close enough to the target! This concludes our tour of classification." 1317 | ] 1318 | }, 1319 | { 1320 | "cell_type": "code", 1321 | "execution_count": null, 1322 | "metadata": {}, 1323 | "outputs": [], 1324 | "source": [] 1325 | } 1326 | ], 1327 | "metadata": { 1328 | "kernelspec": { 1329 | "display_name": "handson", 1330 | "language": "python", 1331 | "name": "handson" 1332 | }, 1333 | "language_info": { 1334 | "codemirror_mode": { 1335 | "name": "ipython", 1336 | "version": 3 1337 | }, 1338 | "file_extension": ".py", 1339 | "mimetype": "text/x-python", 1340 | "name": "python", 1341 | "nbconvert_exporter": "python", 1342 | "pygments_lexer": "ipython3", 1343 | "version": "3.8.5" 1344 | } 1345 | }, 1346 | "nbformat": 4, 1347 | "nbformat_minor": 4 1348 | } 1349 | --------------------------------------------------------------------------------