*1,743*
*683*
*17MB*

*English*
*Pages [269]*
*Year 2020*

- Author / Uploaded
- Venelin Valkov

CONTENTS

Contents TensorFlow 2 and Keras - Quick Start Guide Setup . . . . . . . . . . . . . . . . . . . . . . . Tensors . . . . . . . . . . . . . . . . . . . . . . Simple Linear Regression Model . . . . . . . Simple Neural Network Model . . . . . . . . Save/Restore Model . . . . . . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . . . . References . . . . . . . . . . . . . . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

1 1 2 8 11 14 15 15

Build Your First Neural Network . . Setup . . . . . . . . . . . . . . . . . Fashion data . . . . . . . . . . . . . Data Preprocessing . . . . . . . . . Create your first Neural Network Train your model . . . . . . . . . . Making predictions . . . . . . . . . Conclusion . . . . . . . . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

16 16 17 20 21 23 23 26

End to End Machine Learning Project . Define objective/goal . . . . . . . . . Load data . . . . . . . . . . . . . . . . . Data exploration . . . . . . . . . . . . Prepare the data . . . . . . . . . . . . Build your model . . . . . . . . . . . . Save the model . . . . . . . . . . . . . Build REST API . . . . . . . . . . . . . Deploy to production . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . References . . . . . . . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

28 28 29 30 36 39 43 44 45 46 47

Fundamental Machine Learning Algorithms What Makes a Learning Algorithm? . . . . Our Data . . . . . . . . . . . . . . . . . . . . . Linear Regression . . . . . . . . . . . . . . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

48 48 49 51

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

CONTENTS

Logistic Regression . . . . . . . . . k-Nearest Neighbors . . . . . . . . Naive Bayes . . . . . . . . . . . . . Decision Trees . . . . . . . . . . . . Support Vector Machines (SVM) . Conclusion . . . . . . . . . . . . . . References . . . . . . . . . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

55 57 60 62 64 67 67

Data Preprocessing . . . . . . . . . . . . . . Feature Scaling . . . . . . . . . . . . . . Handling Categorical Data . . . . . . . Adding New Features . . . . . . . . . . Predicting Melbourne Housing Prices Conclusion . . . . . . . . . . . . . . . . . References . . . . . . . . . . . . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

68 68 73 75 76 82 83

Handling Imbalanced Datasets Data . . . . . . . . . . . . . . . Baseline model . . . . . . . . Using the correct metrics . . Weighted model . . . . . . . Resampling techniques . . . Conclusion . . . . . . . . . . . References . . . . . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

84 84 87 92 95 97 103 103

Fixing Underfitting and Overfitting Models Data . . . . . . . . . . . . . . . . . . . . . . . Underfitting . . . . . . . . . . . . . . . . . . Overfitting . . . . . . . . . . . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . . . References . . . . . . . . . . . . . . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

104 106 110 118 125 126

Hyperparameter Tuning . . . . . . . . . . What is a Hyperparameter? . . . . . . When to do Hyperparameter Tuning? Common strategies . . . . . . . . . . . . Finding Hyperparameters . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . References . . . . . . . . . . . . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

127 127 128 128 128 142 143

Heart Disease Prediction Patient Data . . . . . . Data Preprocessing . . The Model . . . . . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

144 144 148 150

. . . .

. . . .

. . . .

. . . .

. . . . . . . .

. . . .

. . . . . . . .

. . . .

. . . . . . . .

. . . .

. . . . . . .

. . . . . . . .

. . . .

. . . . . . .

. . . . . . . .

. . . .

. . . . . . . .

. . . .

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

CONTENTS

Training . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 Predicting Heart Disease . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154 Time Series Forecasting . . . . . . . . . . Time Series . . . . . . . . . . . . . . . Recurrent Neural Networks . . . . . Time Series Prediction with LSTMs . Conclusion . . . . . . . . . . . . . . . . References . . . . . . . . . . . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

155 155 156 157 163 164

Cryptocurrency price prediction using LSTMs Data Overview . . . . . . . . . . . . . . . . . . Time Series . . . . . . . . . . . . . . . . . . . . Modeling . . . . . . . . . . . . . . . . . . . . . . Predicting Bitcoin price . . . . . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

165 165 167 167 172 173

Demand Prediction for Multivariate Time Series with LSTMs Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Feature Engineering . . . . . . . . . . . . . . . . . . . . . . . . . Exploration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Preprocessing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Predicting Demand . . . . . . . . . . . . . . . . . . . . . . . . . . Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

174 174 175 176 179 181 182 183 184

Time Series Classification for Human Activity Recognition with LSTMs in Keras Human Activity Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Classifying Human Activity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

185 185 191 192 194 194

Time Series Anomaly Detection with LSTM Autoencoders using Keras in Python Anomaly Detection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . LSTM Autoencoders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . S&P 500 Index Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . LSTM Autoencoder in Keras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Finding Anomalies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

195 195 196 196 199 200 203 203

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

CONTENTS

Object Detection . . . . . . . Object Detection . . . . . RetinaNet . . . . . . . . . Preparing the Dataset . . Detecting Vehicle Plates . Conclusion . . . . . . . . . References . . . . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

. . . . . . .

204 204 206 207 212 218 219

Image Data Augmentation . . . . . . Tools for Image Augmentation . . Augmenting Scanned Documents Creating Augmented Dataset . . Conclusion . . . . . . . . . . . . . . References . . . . . . . . . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

220 220 221 238 239 240

Sentiment Analysis . . . . . . . . Universal Sentence Encoder Hotel Reviews Data . . . . . Sentiment Analysis . . . . . . Conclusion . . . . . . . . . . . References . . . . . . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

241 241 243 248 251 252

Intent Recognition with BERT . Data . . . . . . . . . . . . . . . . BERT . . . . . . . . . . . . . . . Intent Recognition with BERT Conclusion . . . . . . . . . . . . References . . . . . . . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

253 253 255 255 264 264

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

TensorFlow 2 and Keras - Quick Start Guide TL;DR Learn how to use Tensors, build a Linear Regression model and a simple Neural Network TensorFlow 2.0 (final) was released at the end of September. Oh boy, it looks much cooler than the 1.x series. Why is it so much better for you, the developer? • One high-level API for building models (that you know and love) - Keras. The good news is that most of your old Keras code should work automagically after changing a couple of imports. • Eager execution - all your code looks much more like normal Python programs. Old-timers might remember the horrible Session experiences. You shouldn’t need any of that, in day-today use. There are tons of other improvements, but the new developer experience is something that will make using TensorFlow 2 sweeter. What about PyTorch? PyTorch is still great and easy to use. But it seems like TensorFlow is catching up, or is it? You’ll learn: • • • • • • •

How to install TensorFlow 2 What is a Tensor Doing Tensor math Using probability distributions and sampling Build a Simple Linear Regression model Build a Simple Neural Network model Save/restore a model

Run the complete code in your browser¹

Setup Let’s install the GPU-supported version and set up the environment: ¹https://colab.research.google.com/drive/1HkG7HYS1-IFAYbECZ0zleBWA3Xi4DKIm

TensorFlow 2 and Keras - Quick Start Guide 1

2

!pip install tensorflow-gpu

Check the installed version: 1

import tensorflow as tf

2 3

tf.__version__

1

2.0.0

And specify a random seed, so our results are reproducible: 1

RANDOM_SEED = 42

2 3

tf.random.set_seed(RANDOM_SEED)

Tensors TensorFlow allows you to define and run operations on Tensors. Tensors are data-containers that can be of arbitrary dimension - scalars, vectors, matrices, etc. You can put numbers (floats and ints) and strings into Tensors. Let’s create a simple Tensor:

2

x = tf.constant(1) print(x)

1

tf.Tensor(1, shape=(), dtype=int32)

1

It seems like our first Tensor contains the number 1, it is of type int32 and is shapeless. To obtain the value we can do: 1

x.numpy()

1

1

Let’s create a simple matrix: You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

TensorFlow 2 and Keras - Quick Start Guide 1 2

1 2 3

3

m = tf.constant([[1, 2, 1], [3, 4, 2]]) print(m)

tf.Tensor( [[1 2 1] [3 4 2]], shape=(2, 3), dtype=int32)

This shape thingy seems to specify rows x columns. In general, the shape array shows how many elements are in every dimension of the Tensor.

Helpers TensorFlow offers a variety of helper functions for creating Tensors. Let’s create a matrix full of ones: 1 2

1 2 3 4

ones = tf.ones([3, 3]) print(ones)

tf.Tensor( [[1. 1. 1.] [1. 1. 1.] [1. 1. 1.]], shape=(3, 3), dtype=float32)

and zeros: 1 2

1 2 3

zeros = tf.zeros([2, 3]) print(zeros)

tf.Tensor( [[0. 0. 0.] [0. 0. 0.]], shape=(2, 3), dtype=float32)

We have two rows and three columns. What if we want to turn it into three rows and two columns: 1

tf.reshape(zeros, [3, 2])

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

TensorFlow 2 and Keras - Quick Start Guide 1 2 3 4

tf.Tensor( [[0. 0.] [0. 0.] [0. 0.]], shape=(3, 2), dtype=float32)

You can use another helper function to replace rows and columns (transpose): 1

tf.transpose(zeros)

1

tf.Tensor( [[0. 0.] [0. 0.] [0. 0.]], shape=(3, 2), dtype=float32)

2 3 4

Tensor Math Naturally, you would want to do something with your data. Let’s start with adding numbers: 1 2

a = tf.constant(1) b = tf.constant(1)

3 4

tf.add(a, b).numpy()

1

42

That seems reasonable :) You can do the same thing using something more human friendly: 1

(a + b).numpy()

You can multiply Tensors like so: 1 2

c = a + b c * c

And compute dot product of matrices:

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

4

TensorFlow 2 and Keras - Quick Start Guide 1 2

5

d1 = tf.constant([[1, 2], [1, 2]]); d2 = tf.constant([[3, 4], [3, 4]]);

3 4

tf.tensordot(d1, d2, axes=1).numpy()

1

array([[ 9, 12], [ 9, 12]], dtype=int32)

2

Sampling You can also generate random numbers according to some famous probability distributions. Let’s start with Normal²: 1

norm = tf.random.normal(shape=(1000, 1), mean=0., stddev=1.)

We can do the same thing from the Uniform³:

²https://en.wikipedia.org/wiki/Normal_distribution ³https://en.wikipedia.org/wiki/Uniform_distribution_(continuous) You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

TensorFlow 2 and Keras - Quick Start Guide 1

6

unif = tf.random.uniform(shape=(1000, 1), minval=0, maxval=100)

Let’s have a look at something a tad more exotic - the Poisson distribution⁴. It is popular for modeling the number of times an event occurs in some time. It is the first one (in our exploration) that contains a hyperparameter - $\lambda$. It controls the number of expected occurrences. 1

pois = tf.random.poisson(shape=(1000, 1), lam=0.8) ⁴https://en.wikipedia.org/wiki/Poisson_distribution

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

TensorFlow 2 and Keras - Quick Start Guide

7

The Gamma distribution⁵ is continuous. It has 2 hyperparameters that control the shape and scale. It is used to model always positive continuous variables with skewed distributions. 1

gam = tf.random.gamma(shape=(1000, 1), alpha=0.8) ⁵https://en.wikipedia.org/wiki/Gamma_distribution

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

TensorFlow 2 and Keras - Quick Start Guide

8

Simple Linear Regression Model Let’s build a Simple Linear Regression⁶ model to predict the stopping distance of cars based on their speed. The data comes from here: https://vincentarelbundock.github.io/Rdatasets/datasets.html⁷. It is given by this Tensor: 1 2 3 4 5 6 7 8 9 10 11 12 13 14

data = tf.constant([ [4,2], [4,10], [7,4], [7,22], [8,16], [9,10], [10,18], [10,26], [10,34], [11,17], [11,28], [12,14], [12,20], ⁶https://en.wikipedia.org/wiki/Simple_linear_regression ⁷https://vincentarelbundock.github.io/Rdatasets/datasets.html You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

TensorFlow 2 and Keras - Quick Start Guide 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

[12,24], [12,28], [13,26], [13,34], [13,34], [13,46], [14,26], [14,36], [14,60], [14,80], [15,20], [15,26], [15,54], [16,32], [16,40], [17,32], [17,40], [17,50], [18,42], [18,56], [18,76], [18,84], [19,36], [19,46], [19,68], [20,32], [20,48], [20,52], [20,56], [20,64], [22,66], [23,54], [24,70], [24,92], [24,93], [24,120], [25,85] ])

We can extract the two columns using slicing:

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

9

TensorFlow 2 and Keras - Quick Start Guide 1 2

10

speed = data[:, 0] stopping_distance = data[:, 1]

Let’s have a look at the data:

It seems like a linear model can do a decent job of predicting the stopping distance. Simple Linear Regression finds a straight line that predicts the variable of interest based on a single predictor/feature. Time to build the model using the Keras API: 1 2 3

lin_reg = keras.Sequential([ layers.Dense(1, activation='linear', input_shape=[1]), ])

4 5

optimizer = tf.keras.optimizers.RMSprop(0.001)

6 7 8 9 10 11

lin_reg.compile( loss='mse', optimizer=optimizer, metrics=['mse'] )

We’re using the Sequential API with a single layer - 1 parameter with linear activation. We’ll try to You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

TensorFlow 2 and Keras - Quick Start Guide

11

minimize the Mean squared error⁸ during training. And for the training itself: 1 2 3 4 5 6 7 8

history = lin_reg.fit( x=speed, y=stopping_distance, shuffle=True, epochs=1000, validation_split=0.2, verbose=0 )

We’re breaking any ordering issues by shuffling the data and reserving 20% for validation. Let’s have a look at the training process:

The model is steadily improving during training. That’s a good sign. What can we do with a more complex model?

Simple Neural Network Model Keras (and TensorFlow) was designed as a tool to build Neural Networks. Turns out, Neural Networks are good when a linear model isn’t enough. Let’s create one: ⁸https://en.wikipedia.org/wiki/Mean_squared_error You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

TensorFlow 2 and Keras - Quick Start Guide 1 2 3 4 5 6

12

def build_neural_net(): net = keras.Sequential([ layers.Dense(32, activation='relu', input_shape=[1]), layers.Dense(16, activation='relu'), layers.Dense(1), ])

7 8

optimizer = tf.keras.optimizers.RMSprop(0.001)

9 10 11 12

net.compile(loss='mse', optimizer=optimizer, metrics=['mse', 'accuracy'])

13 14

return net

Things look similar, except for the fact that we stack multiple layers on top of each other. We’re also using a different activation function - ReLU⁹. Training this model looks exactly the same: 1

net = build_neural_net()

2 3 4 5 6 7 8 9 10

history = net.fit( x=speed, y=stopping_distance, shuffle=True, epochs=1000, validation_split=0.2, verbose=0 ) ⁹https://en.wikipedia.org/wiki/Rectifier_(neural_networks)

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

TensorFlow 2 and Keras - Quick Start Guide

13

Seems like we ain’t making much progress after epoch 200 or so. Can we not waste our time waiting for the whole training to complete?

Early Stopping Sure, you can stop the training process manually at say epoch 200. But what if you train another model? What if you obtain more data? You can use the built-in callback EarlyStopping¹⁰ to halt the training when some metric (e.g. the validation loss) stops improving. Let’s see how we can use it: 1 2 3 4

early_stop = keras.callbacks.EarlyStopping( monitor='val_loss', patience=10 )

We want to monitor the validation loss. We’ll observe for improvement for 10 epochs before stopping. Let’s see how we can use it:

¹⁰https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

TensorFlow 2 and Keras - Quick Start Guide 1

14

net = build_neural_net()

2 3 4 5 6 7 8 9 10 11

history = net.fit( x=speed, y=stopping_distance, shuffle=True, epochs=1000, validation_split=0.2, verbose=0, callbacks=[early_stop] )

Effectively, we’ve cut down the number of training epochs to ∼120. Is this going to work every time that well? Not really. Using early stopping introduces yet another hyperparameter that you need to consider when training your model. Use it cautiously. Now your model is ready for the real world. How can you store it for later use?

Save/Restore Model You can save the complete model (including weights) like this:

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

TensorFlow 2 and Keras - Quick Start Guide 1

net.save('simple_net.h5')

And load it like that: 1

simple_net = keras.models.load_model('simple_net.h5')

You can use this mechanism to deploy your model and use it in production (for example).

Conclusion You did it! You now know (a tiny bit) TensorFlow 2! Let’s recap what you’ve learned: • • • • • • •

How to install TensorFlow 2 What is a Tensor Doing Tensor math Using probability distributions and sampling Build a Simple Linear Regression model Build a Simple Neural Network model Save/restore a model

Run the complete code in your browser¹¹ Stay tuned for more :)

References • TensorFlow 2.0 released¹² • TensorFlow 2.0 on GitHub¹³ • Effective TensorFlow 2.0¹⁴ ¹¹https://colab.research.google.com/drive/1HkG7HYS1-IFAYbECZ0zleBWA3Xi4DKIm ¹²https://medium.com/tensorflow/tensorflow-2-0-is-now-available-57d706c2a9ab ¹³https://github.com/tensorflow/tensorflow/releases/tag/v2.0.0 ¹⁴https://www.tensorflow.org/guide/effective_tf2

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

15

Build Your First Neural Network TL;DR Build and train your first Neural Network model using TensorFlow 2. Use the model to recognize clothing type from images. Ok, I’ll start with a secret — I am THE fashion wizard (as long as we’re talking tracksuits). Fortunately, there are ways to get help, even for someone like me! Can you imagine a really helpful browser extension for “fashion accessibility”? Something that tells you what the type of clothing you’re looking at. After all, I really need something like this. I found out nothing like this exists, without even searching for it. Let’s make a Neural Network that predicts clothing type from an image! Here’s what we are going to do: 1. 2. 3. 4. 5.

Install TensorFlow 2 Take a look at some fashion data Transform the data, so it is useful for us Create your first Neural Network in TensorFlow 2 Predict what type of clothing is showing on images your Neural Network haven’t seen

Setup With TensorFlow 2 just around the corner (not sure how far along that corner is thought) making your first Neural Network has never been easier (as far as TensorFlow goes). But what is TensorFlow¹⁵? Machine Learning platform (really Google?) created and open sourced by Google. Note that TensorFlow is not a special purpose library for creating Neural Networks, although it is primarily used for that purpose. So, what TensorFlow 2 has in store for us? TensorFlow 2.0 focuses on simplicity and ease of use, with updates like eager execution, intuitive higher-level APIs, and flexible model building on any platform Alright, let’s check those claims and install TensorFlow 2 from your terminal:

¹⁵https://www.tensorflow.org/overview

Build Your First Neural Network 1

17

pip install tensorflow-gpu==2.0.0-alpha0

Fashion data Your Neural Network needs something to learn from. In Machine Learning that something is called datasets. The dataset for today is called Fashion MNIST¹⁶. Fashion-MNIST is a dataset of Zalando’s article images¹⁷ — consisting of a training set

of 60,000 examples and a test set of 10,000 examples. Each example is a 28x28 grayscale image, associated with a label from 10 classes. In other words, we have 70,000 images of 28 pixels width and 28 pixels height in greyscale. Each image is showing one of 10 possible clothing types. Here is one: ¹⁶https://github.com/zalandoresearch/fashion-mnist ¹⁷https://jobs.zalando.com/en/

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Build Your First Neural Network

Here are some images from the dataset along with the clothing they are showing:

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

18

Build Your First Neural Network

Here are all different types of clothing:

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

19

20

Build Your First Neural Network

Label 0 1 2 3 4 5 6 7 8 9

Description T-shirt/top Trouser Pullover Dress Coat Sandal Shirt Sneaker Bag Ankle boot

Now that we got familiar with the data we have let’s make it usable for our Neural Network.

Data Preprocessing Let’s start with loading our data into memory: 1 2

import tensorflow as tf from tensorflow import keras

3 4

(x_train, y_train), (x_val, y_val) = keras.datasets.fashion_mnist.load_data()

Fortunately, TensorFlow has the dataset built-in, so we can easily obtain it. Loading it gives us 4 things: x_train — image (pixel) data for 60,000 clothes. Used for training our model. y_train — classes (clothing type) for the clothing above. Used for training our model. x_val — image (pixel) data for 10,000 clothes. Used for testing/validating our model. y_val — classes (clothing type) for the clothing above. Used for testing/validating our model.

Now, your Neural Network can’t really see images as you do. But it can understand numbers. Each data point of each image in our dataset is pixel data — a number between 0 and 255. We would like that data to be transformed (Why? While the truth is more nuanced, one can say it helps with training a better model) in the range 0–1. How can we do it? We will use the Dataset¹⁸ from TensorFlow to prepare our data:

¹⁸https://www.tensorflow.org/api_docs/python/tf/data/Dataset You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Build Your First Neural Network 1 2 3

21

def preprocess(x, y): x = tf.cast(x, tf.float32) / 255.0 y = tf.cast(y, tf.int64)

4

return x, y

5 6 7 8 9 10 11 12

def create_dataset(xs, ys, n_classes=10): ys = tf.one_hot(ys, depth=n_classes) return tf.data.Dataset.from_tensor_slices((xs, ys)) \ .map(preprocess) \ .shuffle(len(ys)) \ .batch(128)

Let’s unpack what is happening here. What does tf.one_hot do? Let’s say you have the following vector: [1, 2, 3, 1]

Here is the one-hot encoded version of it: 1

[ [1, [0, [0, [1,

2 3 4 5 6

0, 1, 0, 0,

0], 0], 1], 0]

]

It puts 1 at the index position of the number and 0 everywhere else. We create Dataset from the data using from_tensor_slices¹⁹ and divide each pixel of the images by 255 to scale it in the 0–1 range. Then we use shuffle²⁰ and batch²¹ to convert the data into chunks. Why shuffle the data, though? We don’t want our model to make predictions based on the order of the training data, so we just shuffle it. I am truly sorry for this bad joke²²

Create your first Neural Network You’re doing great! It is time for the fun part, use the data to create your first Neural Network. ¹⁹https://www.tensorflow.org/api_docs/python/tf/data/Dataset#from_tensor_slices ²⁰https://www.tensorflow.org/api_docs/python/tf/data/Dataset#shuffle ²¹https://www.tensorflow.org/api_docs/python/tf/data/Dataset#batch ²²https://www.youtube.com/watch?v=KQ6zr6kCPj8 You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Build Your First Neural Network 1 2

22

train_dataset = create_dataset(x_train, y_train) val_dataset = create_dataset(x_val, y_val)

Build your Neural Network using Keras layers They say TensorFlow 2 has an easy High-level API, let’s take it for a spin: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

model = keras.Sequential([ keras.layers.Reshape( target_shape=(28 * 28,), input_shape=(28, 28) ), keras.layers.Dense( units=256, activation='relu' ), keras.layers.Dense( units=192, activation='relu' ), keras.layers.Dense( units=128, activation='relu' ), keras.layers.Dense( units=10, activation='softmax' ) ])

Turns out the High-level API is the old Keras²³ API which is great. Most Neural Networks are built by “stacking” layers. Think pancakes or lasagna. Your first Neural Network is really simple. It has 5 layers. The first (Reshape²⁴) layer is called an input layer and takes care of converting the input data for the layers below. Our images are 28*28=784 pixels. We’re just converting the 2D 28x28 array to a 1D 784 array. All other layers are Dense²⁵ (interconnected). You might notice the parameter units, it sets the number of neurons for each layer. The activation parameter specifies a function that decides whether “the opinion” of a particular neuron, in the layer, should be taken into account and to what degree. There are a lot of activation functions one can use. The last (output) layer is a special one. It has 10 neurons because we have 10 different types of clothing in our data. You get the predictions of the model from this layer. ²³https://keras.io/ ²⁴https://www.tensorflow.org/api_docs/python/tf/keras/layers/Reshape ²⁵https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dense You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

23

Build Your First Neural Network

Train your model Right now your Neural Network is plain dumb. It is like a shell without a soul (good that you get that). Let’s train it using our data: 1 2 3 4 5

model.compile( optimizer='adam', loss=tf.losses.CategoricalCrossentropy(from_logits=True), metrics=['accuracy'] )

6 7 8 9 10 11 12 13

history = model.fit( train_dataset.repeat(), epochs=10, steps_per_epoch=500, validation_data=val_dataset.repeat(), validation_steps=2 )

Training a Neural Network consists of deciding on objective measurement of accuracy and an algorithm that knows how to improve on that. TensorFlow allows us to specify the optimizer algorithm we’re going to use — Adam²⁶ and the measurement (loss function) — CategoricalCrossentropy²⁷ (we’re choosing/classifying 10 different types of clothing). We’re measuring the accuracy of the model during the training, too! The actual training takes place when the fit method is called. We give our training and validation data to it and specify how many epochs we’re training for. During one training epoch, all data is shown to the model. Here is a sample result of our training: 1 2 3 4 5

Epoch 1/10 500/500 accuracy: 0.7303 Epoch 2/10 500/500 accuracy: 0.7807 ...

[==============================] val_loss: 1.6871 - val_accuracy: [==============================] val_loss: 1.6795 - val_accuracy:

- 9s 18ms/step - loss: 1.7340 - \ 0.7812 - 6s 12ms/step - loss: 1.6806 - \ 0.7812

I got ∼82% accuracy on the validation set after 10 epochs. Lets profit from our model!

Making predictions Now that your Neural Network “learned” something lets try it out: ²⁶https://www.tensorflow.org/api_docs/python/tf/train/AdamOptimizer ²⁷https://www.tensorflow.org/api_docs/python/tf/keras/losses/CategoricalCrossentropy You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Build Your First Neural Network 1

24

predictions = model.predict(val_dataset)

Here is a sample prediction: 1 2 3 4 5 6 7 8 9 10 11 12

array([ 1.8154810e-07, 1.0657334e-09, 9.9998713e-01, 1.1928002e-05, 2.9766360e-08, 4.0670972e-08, 2.5100772e-07, 4.5147233e-11, 2.9812568e-07, 3.5224868e-11 ], dtype=float32)

Recall that we have 10 different clothing types. Our model outputs a probability distribution about how likely each clothing type is shown on an image. To make a decision, we can get the one with the highest probability: 1

np.argmax(predictions[0])

2 Here is one correct and one wrong prediction from our model:

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Build Your First Neural Network

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

25

Build Your First Neural Network

26

Conclusion Alright, you got your first Neural Network running and made some predictions! You can take a look at the Google Colaboratory Notebook (including more charts) here: Google Colaboratory Notebook²⁸ ²⁸https://colab.research.google.com/drive/1ctyhVlD9Y85KTBma1X9Zf35Q0ha9PCaP

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Build Your First Neural Network

27

One day you might realize that your relationship with Machine Learning is similar to marriage. The problems you might encounter are similar, too! What Makes Marriages Work by John Gottman, Nan Silver²⁹ lists 5 problems marriages have: “Money, Kids, Sex, Time, Others”. Here are the Machine Learning counterparts:

Shall we tackle them together? ²⁹https://www.psychologytoday.com/intl/articles/199403/what-makes-marriage-work

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project TL;DR Step-by-step guide to build a Deep Neural Network model with Keras to predict Airbnb prices in NYC and deploy it as REST API using Flask This guide will let you deploy a Machine Learning model starting from zero. Here are the steps you’re going to cover: • • • • • • • •

Define your goal Load data Data exploration Data preparation Build and evalute your model Save the model Build REST API Deploy to production

There is a lot to cover, but every step of the way will get you closer to deploying your model to the real-world. Let’s begin! Run the modeling code in your browser³⁰ The complete project on GitHub³¹

Define objective/goal Obviously, you need to know why you need a Machine Learning (ML) model in the first place. Knowing the objective gives you insights about: • • • • •

Is ML the right approach? What data do I need? What a “good model” will look like? What metrics can I use? How do I solve the problem right now? How accurate is the solution? How much is it going to cost to keep this model running?

In our example, we’re trying to predict Airbnb³² listing price per night in NYC. Our objective is clear - given some data, we want our model to predict how much will it cost to rent a certain property per night. ³⁰https://colab.research.google.com/drive/1YxCmQb2YKh7VuQ_XgPXhEeIM3LpjV-mS ³¹https://github.com/curiousily/Deploy-Keras-Deep-Learning-Model-with-Flask ³²https://www.airbnb.com/

End to End Machine Learning Project

Load data The data comes from Airbnb Open Data and it is hosted on Kaggle³³ Since 2008, guests and hosts have used Airbnb to expand on traveling possibilities and present more unique, personalized way of experiencing the world. This dataset describes the listing activity and metrics in NYC, NY for 2019.

Setup We’ll start with a bunch of imports and setting a random seed for reproducibility: 1 2 3 4 5 6 7 8 9 10

import numpy as np import tensorflow as tf from tensorflow import keras import pandas as pd import seaborn as sns from pylab import rcParams import matplotlib.pyplot as plt from matplotlib import rc from sklearn.model_selection import train_test_split import joblib

11 12 13

%matplotlib inline %config InlineBackend.figure_format='retina'

14 15

sns.set(style='whitegrid', palette='muted', font_scale=1.5)

16 17

rcParams['figure.figsize'] = 16, 10

18 19

RANDOM_SEED = 42

20 21 22

np.random.seed(RANDOM_SEED) tf.random.set_seed(RANDOM_SEED)

Download the data from Google Drive with gdown: 1

!gdown --id 1aRXGcJlIkuC6uj1iLqzi9DQQS-3GPwM_ --output airbnb_nyc.csv

And load it into a Pandas DataFrame: ³³https://www.kaggle.com/dgomonov/new-york-city-airbnb-open-data You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

29

End to End Machine Learning Project 1

30

df = pd.read_csv('airbnb_nyc.csv')

How can we understand what our data is all about?

Data exploration This step is crucial. The goal is to get a better understanding of the data. You might be tempted to jumpstart the modeling process, but that would be suboptimal. Looking at large amounts of examples, looking for patterns and visualizing distributions will build your intuition about the data. That intuition will be helpful when modeling, imputing missing data and looking at outliers. One easy way to start is to count the number of rows and columns in your dataset: 1

df.shape

1

(48895, 16)

We have 48,895 rows and 16 columns. Enough data to do something interesting. Let’s start with the variable we’re trying to predict price. To plot the distribution, we’ll use distplot(): 1

sns.distplot(df.price)

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project

31

We have a highly skewed distribution with some values in the 10,000 range (you might want to explore those). We’ll use a trick - log transformation: 1

sns.distplot(np.log1p(df.price))

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project

32

This looks more like a normal distribution. Turns out this might help your model better learn the data³⁴. You’ll have to remember to preprocess the data before training and predicting. The type of room seems like another interesting point. Let’s have a look: 1

sns.countplot(x='room_type', data=df) ³⁴https://datascience.stackexchange.com/questions/40089/what-is-the-reason-behind-taking-log-transformation-of-few-continuousvariables

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project

33

Most listings are offering entire places or private rooms. What about the location? What neighborhood groups are most represented? 1

sns.countplot(x='neighbourhood_group', data=df)

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project

34

As expected, Manhattan leads the way. Obviously, Brooklyn is very well represented, too. You can thank Mos Def, Nas, Masta Ace, and Fabolous for that. Another interesting feature is the number of reviews. Let’s have a look at it: 1

sns.distplot(df.number_of_reviews)

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project

35

This one seems to follow a Power law³⁵ (it has a fat tail). This one seems to follow a Power law³⁶ (it has a fat tail). There seem to be some outliers (on the right) that might be of interest for investigation.

Finding Correlations The correlation analysis might give you hints at what features might have predictive power when training your model. Remember, Correlation does not imply causation³⁷ Computing Pearson correlation coefficient³⁸ between a pair of features is easy: 1

corr_matrix = df.corr()

Let’s look at the correlation of the price with the other attributes:

³⁵https://en.wikipedia.org/wiki/Power_law ³⁶https://en.wikipedia.org/wiki/Power_law ³⁷https://en.wikipedia.org/wiki/Correlation_does_not_imply_causation ³⁸https://en.wikipedia.org/wiki/Pearson_correlation_coefficient You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

36

End to End Machine Learning Project 1 2

1 2 3 4 5 6 7

price_corr = corr_matrix['price'] price_corr.iloc[price_corr.abs().argsort()]

latitude minimum_nights number_of_reviews calculated_host_listings_count availability_365 longitude price

0.033939 0.042799 -0.047954 0.057472 0.081829 -0.150019 1.000000

The correlation coefficient is defined in the -1 to 1 range. A value close to 0 means there is no correlation. Value of 1 suggests a perfect positive correlation (e.g. as the price of Bitcoin increases, your dreams of owning more are going up, too!). Value of -1 suggests perfect negative correlation (e.g. high number of bad reviews should correlate with lower prices). The correlation in our dataset looks really bad. Luckily, categorical features are not included here. They might have some predictive power too! How can we use them?

Prepare the data The goal here is to transform the data into a form that is suitable for your model. There are several things you want to do when handling (think CSV, Database) structured data: • • • •

Handle missing data Remove unnecessary columns Transform any categorical features to numbers/vectors Scale numerical features

Missing data Let’s start with a check for missing data: 1 2

missing = df.isnull().sum() missing[missing > 0].sort_values(ascending=False)

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project 1 2 3 4

reviews_per_month last_review host_name name

37

10052 10052 21 16

We’ll just go ahead and remove those features for this example. In real-world applications, you should consider other approaches. 1 2 3 4

df = df.drop([ 'id', 'name', 'host_id', 'host_name', 'reviews_per_month', 'last_review', 'neighbourhood' ], axis=1)

We’re also dropping the neighbourhood, host id (too many unique values), and the id of the listing. Next, we’re splitting the data into features we’re going to use for the prediction and a target variable y (the price): 1 2

X = df.drop('price', axis=1) y = np.log1p(df.price.values)

Note that we’re applying the log transformation to the price.

Feature scaling and categorical data Let’s start with feature scaling³⁹. Specifically, we’ll do min-max normalization and scale the features in the 0-1 range. Luckily, the MinMaxScaler⁴⁰ from scikit-learn does just that. But why do feature scaling at all? Largely because of the algorithm we’re going to use to train our model⁴¹ will do better with it. Next, we need to preprocess the categorical data. Why? Some Machine Learning algorithms can operate on categorical data without any preprocessing (like Decision trees, Naive Bayes). But most can’t. Unfortunately, you can’t replace the category names with a number. Converting Brooklyn to 1 and Manhattan to 2 suggests that Manhattan is greater (2 times) than Brooklyn. That doesn’t make sense. How can we solve this? We can use One-hot encoding⁴². To get a feel of what it does, we’ll use OneHotEncoder⁴³ from scikit-learn: ³⁹https://en.wikipedia.org/wiki/Feature_scaling ⁴⁰https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html ⁴¹https://arxiv.org/abs/1502.03167 ⁴²https://en.wikipedia.org/wiki/One-hot ⁴³https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project 1

38

from sklearn.preprocessing import OneHotEncoder

2 3

data = [['Manhattan'], ['Brooklyn']]

4 5

OneHotEncoder(sparse=False).fit_transform(data)

1

array([[0., 1.], [1., 0.]])

2

Essentially, you get a vector for each value that contains 1 at the index of the category and 0 for every other value. This encoding solves the comparison issue. The negative part is that your data now might take much more memory. All data preprocessing steps are to be performed on the training data and data we’re going to receive via the REST API for prediction. We can unite the steps using make_column_transformer()⁴⁴: 1 2

from sklearn.preprocessing import MinMaxScaler, OneHotEncoder from sklearn.compose import make_column_transformer

3 4 5 6 7 8 9 10 11 12

transformer = make_column_transformer( (MinMaxScaler(), [ 'latitude', 'longitude', 'minimum_nights', 'number_of_reviews', 'calculated_host_listings_count', 'availability_365' ]), (OneHotEncoder(handle_unknown="ignore"), [ 'neighbourhood_group', 'room_type' ]) )

We enumerate all columns that need feature scaling and one-hot encoding. Those columns will be replaced with the ones from the preprocessing steps. Next, we’ll learn the ranges and categorical mapping using our transformer: 1

transformer.fit(X)

Finally, we’ll transform our data: 1

transformer.transform(X)

The last thing is to separate the data into training and test sets: ⁴⁴https://scikit-learn.org/stable/modules/generated/sklearn.compose.make_column_transformer.html You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

39

End to End Machine Learning Project 1 2

X_train, X_test, y_train, y_test =\ train_test_split(X, y, test_size=0.2, random_state=RANDOM_SEED)

You’re going to use only the training set while developing and evaluating your model. The test set will be used later. That’s it! You are now ready to build a model. How can you do that?

Build your model Finally, it is time to do some modeling. Recall the goal we set for ourselves at the beginning: We’re trying to predict Airbnb⁴⁵ listing price per night in NYC We have a price prediction problem on our hands. More generally, we’re trying to predict a numerical value defined in a very large range. This fits nicely in the Regression Analysis⁴⁶ framework. Training a model boils down to minimizing some predefined error. What error should we measure?

Error measurement We’ll use Mean Squared Error⁴⁷ which measures the difference between average squared predicted and true values: 1∑ (Yi − Yˆi )2 n i=1 n

MSE =

where $n$ is the number of samples, $Y$ is a vector containing the real values and $\hat{Y}$ is a vector containing the predictions from our model. Now that you have a measurement of how well your model is performing is time to build the model itself. How can you build a Deep Neural Network with Keras?

Build a Deep Neural Network with Keras Keras⁴⁸ is the official high-level API for TensorFlow⁴⁹. In short, it allows you to build complex models using a sweet interface. Let’s build a model with it: ⁴⁵https://www.airbnb.com/ ⁴⁶https://en.wikipedia.org/wiki/Regression_analysis ⁴⁷https://en.wikipedia.org/wiki/Mean_squared_error ⁴⁸https://keras.io/ ⁴⁹https://www.tensorflow.org/ You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project 1 2 3 4 5 6 7 8 9

40

model = keras.Sequential() model.add(keras.layers.Dense( units=64, activation="relu", input_shape=[X_train.shape[1]] )) model.add(keras.layers.Dropout(rate=0.3)) model.add(keras.layers.Dense(units=32, activation="relu")) model.add(keras.layers.Dropout(rate=0.5))

10 11

model.add(keras.layers.Dense(1))

The sequential API allows you to add various layers to your model, easily. Note that we specify the input_size in the first layer using the training data. We also do regularization using Dropout layers⁵⁰. How can we specify the error metric? 1 2 3 4

model.compile( optimizer=keras.optimizers.Adam(0.0001), loss = 'mae', metrics = ['mae'])

The compile()⁵¹ method lets you specify the optimizer and the error metric you need to reduce. Your model is ready for training. Let’s go!

Training Training a Keras model involves calling a single method - fit()⁵²: 1

BATCH_SIZE = 32

2 3 4 5 6 7

early_stop = keras.callbacks.EarlyStopping( monitor='val_mae', mode="min", patience=10 )

8 9

history = model.fit( ⁵⁰https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dropout ⁵¹https://www.tensorflow.org/api_docs/python/tf/keras/Model#compile ⁵²https://www.tensorflow.org/api_docs/python/tf/keras/Model#fit

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project

x=X_train, y=y_train, shuffle=True, epochs=100, validation_split=0.2, batch_size=BATCH_SIZE, callbacks=[early_stop]

10 11 12 13 14 15 16 17

41

)

We feed the training method with the training data and specify the following parameters: • • • • •

shuffle - random sort the data epochs - number of training cycles validation_split - use some percent of the data for measuring the error and not during training batch_size - the number of training examples that are fed at a time to our model callbacks - we use EarlyStopping⁵³ to prevent our model from overfitting when the training and validation error start to diverge

After the long training process is complete, you need to answer one question. Can your model make good predictions?

Evaluation One simple way to understand the training process is to look at the training and validation loss: ⁵³https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project

42

We can see a large improvement in the training error, but not much on the validation error. What else can we use to test our model? Using the test data Recall that we have some additional data. Now it is time to use it and test how good our model. Note that we don’t use that data during the training, only once at the end of the process. Let’s get the predictions from the model: 1

y_pred = model.predict(X_test)

And we’ll use a couple of metrics for the evaluation: 1 2 3

from sklearn.metrics import mean_squared_error from math import sqrt from sklearn.metrics import r2_score

4 5 6

print(f'MSE {mean_squared_error(y_test, y_pred)}') print(f'RMSE {np.sqrt(mean_squared_error(y_test, y_pred))}')

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project 1 2

43

MSE 0.2139184014903989 RMSE 0.4625131365598159

We’ve already discussed MSE. You can probably guess what Root Mean Squared Error (RMSE)⁵⁴ means. RMSE allows us to penalize points further from the mean. Another statistic we can use to measure how well our predictions fit with the real data is the $R^2$ score⁵⁵. A value close to 1 indicates a perfect fit. Let’s check ours: 1

print(f'R2 {r2_score(y_test, y_pred)}')

1

R2 0.5478250409482018

There is definitely room for improvement here. You might try to tune the model better and get better results. Now you have a model and a rough idea of how well will it do in production. How can you save your work?

Save the model Now that you have a trained model, you need to store it and be able to reuse it later. Recall that we have a data transformer that needs to be stored, too! Let’s save both: 1

import joblib

2 3 4

joblib.dump(transformer, "data_transformer.joblib") model.save("price_prediction_model.h5")

The recommended approach of storing scikit-learn models⁵⁶ is to use joblib⁵⁷. Saving the model architecture and weights of a Keras model is done with the save()⁵⁸ method. You can download the files from the notebook using the following:

⁵⁴https://en.wikipedia.org/wiki/Root-mean-square_deviation ⁵⁵https://en.wikipedia.org/wiki/Coefficient_of_determination ⁵⁶https://scikit-learn.org/stable/modules/model_persistence.html#persistence-example ⁵⁷https://joblib.readthedocs.io/en/latest/ ⁵⁸https://www.tensorflow.org/api_docs/python/tf/keras/Sequential#save You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project 1

44

from google.colab import files

2 3 4

files.download("data_transformer.joblib") files.download("price_prediction_model.h5")

Build REST API Building a REST API⁵⁹ allows you to use your model to make predictions for different clients. Almost any device can speak REST - Android, iOS, Web browsers, and many others. Flask⁶⁰ allows you to build a REST API in just a couple of lines. Of course, we’re talking about a quick-and-dirty prototype. Let’s have a look at the complete code: 1

from math import expm1

2 3 4 5 6

import joblib import pandas as pd from flask import Flask, jsonify, request from tensorflow import keras

7 8 9 10

app = Flask(__name__) model = keras.models.load_model("assets/price_prediction_model.h5") transformer = joblib.load("assets/data_transformer.joblib")

11 12 13 14 15 16 17 18 19

@app.route("/", methods=["POST"]) def index(): data = request.json df = pd.DataFrame(data, index=[0]) prediction = model.predict(transformer.transform(df)) predicted_price = expm1(prediction.flatten()[0]) return jsonify({"price": str(predicted_price)})

The complete project (including the data transformer and model) is on GitHub: Deploy Keras Deep Learning Model with Flask⁶¹ The API has a single route (index) that accepts only POST requests. Note that we pre-load the data transformer and the model. ⁵⁹https://en.wikipedia.org/wiki/Representational_state_transfer ⁶⁰https://www.fullstackpython.com/flask.html ⁶¹https://github.com/curiousily/Deploy-Keras-Deep-Learning-Model-with-Flask

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project

45

The request handler obtains the JSON data and converts it into a Pandas DataFrame. Next, we use the transformer to pre-process the data and get a prediction from our model. We invert the log operation we did in the pre-processing step and return the predicted price as JSON. Your REST API is ready to go. Run the following command in the project directory: 1

flask run

Open a new tab to test the API: 1 2 3 4

curl -d '{"neighbourhood_group": "Brooklyn", "latitude": 40.64749, "longitude": -73.\ 97237, "room_type": "Private room", "minimum_nights": 1, "number_of_reviews": 9, "ca\ lculated_host_listings_count": 6, "availability_365": 365}' -H "Content-Type: applic\ ation/json" -X POST http://localhost:5000

You should see something like the following: 1

{"price":"72.70381414559431"}

Great. How can you deploy your project and allow others to consume your model predictions?

Deploy to production We’ll deploy the project to Google App Engine⁶²: App Engine enables developers to stay more productive and agile by supporting popular development languages and a wide range of developer tools. App Engine allows us to use Python and easily deploy a Flask app. You need to: • Register for Google Cloud Engine account⁶³ • Google Cloud SDK installed⁶⁴ Here is the complete app.yaml config:

⁶²https://cloud.google.com/appengine/ ⁶³https://cloud.google.com/compute/ ⁶⁴https://cloud.google.com/sdk/install You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project 1 2 3 4 5 6 7 8 9 10 11

46

entrypoint: "gunicorn -b :$PORT app:app --timeout 500" runtime: python env: flex service: nyc-price-prediction runtime_config: python_version: 3.7 instance_class: B1 manual_scaling: instances: 1 liveness_check: path: "/liveness_check"

Execute the following command to deploy the project: 1

gcloud app deploy

Wait for the process to complete and test the API running on production. You did it!

Conclusion Your model should now be running, making predictions, and accessible to everyone. Of course, you have a quick-and-dirty prototype. You will need a way to protect and monitor your API. Maybe you need a better (automated) deployment strategy too! Still, you have a model deployed in production and did all of the following: • • • • • • • •

Define your goal Load data Data exploration Data preparation Build and evalute your model Save the model Build REST API Deploy to production

How do you deploy your models? Comment down below :) Run the modeling code in your browser⁶⁵ The complete project on GitHub⁶⁶ ⁶⁵https://colab.research.google.com/drive/1YxCmQb2YKh7VuQ_XgPXhEeIM3LpjV-mS ⁶⁶https://github.com/curiousily/Deploy-Keras-Deep-Learning-Model-with-Flask

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

End to End Machine Learning Project

References • Joblib - running Python functions as pipeline jobs⁶⁷ • Flask - lightweight web application framework⁶⁸ • Building a simple Keras + deep learning REST API⁶⁹ ⁶⁷https://joblib.readthedocs.io/en/latest/ ⁶⁸https://palletsprojects.com/p/flask/ ⁶⁹https://blog.keras.io/building-a-simple-keras-deep-learning-rest-api.html

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

47

Fundamental Machine Learning Algorithms TL;DR Overview of fundamental classification and regression learning algorithms. Learn when should you use each and what data preprocessing is required. Each algorithm is presented along with an example done in scikit-learn. This guide explores different supervised learning algorithms⁷⁰, sorted by increasing complexity (measured by the number of model parameters and hyperparameters). I would strongly suggest you start with the simpler ones when working on a new project/problem. But why not just use Deep Neural Networks for everything? You can, and maybe you should. But simplicity can go a long way before the need for ramping up the complexity in your project. It is also entirely possible to not be able to tune your Neural Net to beat some of the algorithms described here. You’re going to learn about: • • • • • •

Linear Regression Logistic Regression k-Nearest Neighbors Naive Bayes Decision Trees Support Vector Machines

Run the complete notebook in your browser⁷¹ The complete project on GitHub⁷²

What Makes a Learning Algorithm? In their essence, supervised Machine Learning algorithms learn a mapping function f that maps the data features X to labels y. The goal is to make the mapping as accurate as possible. We can define the problem as: y = f (X) + e ⁷⁰https://en.wikipedia.org/wiki/Supervised_learning ⁷¹https://colab.research.google.com/drive/1-_wQbYW-KqDNMkT9iZ-d2KWVHyR6d0nn ⁷²https://github.com/curiousily/Deep-Learning-For-Hackers

Fundamental Machine Learning Algorithms

49

where e is an irreducible error. That error is independent of the data and can’t be lowered using the data (hence the name). The problem of finding the function f is notoriously difficult. In practice, you’ll be content with a good approximation. There are many ways to get the job done. What do they have in common?

Components of a Learning Algorithm • Loss functions • Optimizer that tries to minimize the loss function The Loss Function⁷³ outputs a numerical value that shows how “bad” your model predictions are. The closer the value is to 0, the better the predictions. The optimizer’s job is to find the best possible values for the model parameters that minimize the loss function. This is done with the help of the training data and an algorithm that searches for the parameter values. Gradient Descent⁷⁴ is the most commonly used algorithm for optimization. It finds a local minimum of a function by starting at a random point and takes steps in a direction and size given by the gradient.

Our Data We’ll use the Auto Data Set⁷⁵ to create examples for various classification and regression algorithms. Gas mileage, horsepower, and other information for 392 vehicles. This dataset was taken from the StatLib library which is maintained at Carnegie Mellon University. The dataset was used in the 1983 American Statistical Association Exposition. Let’s download the data and load it into a Pandas data frame: 1

!gdown --id 16VDAc-x1fGa2lpsI8xtLHK6z_3m36JBx --output auto.csv

1

auto_df = pd.read_csv("auto.csv", index_col=0) auto_df.shape

2

⁷³https://en.wikipedia.org/wiki/Loss_function ⁷⁴https://en.wikipedia.org/wiki/Gradient_descent ⁷⁵https://vincentarelbundock.github.io/Rdatasets/doc/ISLR/Auto.html You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Fundamental Machine Learning Algorithms 1

50

(392, 9)

We have 392 vehicles and we’ll use this subset of the features: • • • • •

mpg - miles per gallon horsepower - Engine horsepower weight - Vehicle weight (lbs.) acceleration - Time to accelerate from 0 to 60 mph (sec.) origin - Origin of car (1. American, 2. European, 3. Japanese)

We have no missing data.

Data Preprocessing We’re going to define two helper functions that prepare a classification and a regression dataset based on our data. But first, we’re going to add a new feature that specifies whether a car is American made or not: 1

auto_df['is_american'] = (auto_df.origin == 1).astype(int)

We’re going to use the StandarScaler⁷⁶ to scale our datasets: 1

from sklearn.preprocessing import StandardScaler

2 3 4 5 6

def create_regression_dataset( df, columns=['mpg', 'weight', 'horsepower'] ):

7 8 9

all_columns = columns.copy() all_columns.append('acceleration')

10 11 12 13

reg_df = df[all_columns] reg_df = StandardScaler().fit_transform(reg_df[all_columns]) reg_df = pd.DataFrame(reg_df, columns=all_columns)

14 15

return reg_df[columns], reg_df.acceleration

16 17 18

def create_classification_dataset(df): columns = ['mpg', 'weight', 'horsepower'] ⁷⁶https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Fundamental Machine Learning Algorithms

51

19 20 21 22

X = df[columns] X = StandardScaler().fit_transform(X) X = pd.DataFrame(X, columns=columns)

23 24

return X, df.is_american

Evaluation We’re going to use k-fold cross validation⁷⁷ to evaluate the performance of our models. Note that this guide is NOT benchmarking model performance. Here are the definitions of our evaluation functions: 1

from sklearn.model_selection import KFold, cross_val_score

2 3 4 5 6

def eval_model(model, X, y, score): cv = KFold(n_splits=10, random_state=RANDOM_SEED) results = cross_val_score(model, X, y, cv=cv, scoring=score) return np.abs(results.mean())

7 8 9

def eval_classifier(model, X, y): return eval_model(model, X, y, score="accuracy")

10 11 12

def eval_regressor(model, X, y): return eval_model(model, X, y, score="neg_mean_squared_error")

We are using accuracy (percent of correctly predicted examples) as a metric for our classification examples and mean squared error (explained below) for the regression examples.

Linear Regression Linear Regression⁷⁸ tries to build a line that can best describe the relationship between two variables X and Y . That line is called “best-fit” and is closest to the points (xi , yi ). ⁷⁷https://en.wikipedia.org/wiki/Cross-validation_(statistics)#k-fold_cross-validation ⁷⁸https://en.wikipedia.org/wiki/Linear_regression

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

52

Fundamental Machine Learning Algorithms

Y is known as the dependent variable and it is continious - e.g. number of sales, price, weight. This is the variable which values we’re trying to predict. X is known as explanatory (or independent) variable. We use this variable to predict the value of Y . Note that we’re assuming a linear relationship

between the variables.

Definition Our dataset consists of m labeled examples (xi , yi ), where xi is D-dimensional feature vector, yi ∈ R and every feature xji ∈ R, j = 1, . . . , D. We want to build a model that predicts unknown y for a given x. Our model is defined as: fw,b (x) = wx + b

where w and b are parameters of our model that we’ll learn from the data. w defines the slope of the model, while b defines the intercept point with the vertical axis.

Making Predictions Linear regression that makes the most accurate prediction has optimal values for the parameters w and b. Let’s denote those as w∗ and b∗ . How can we find those values? You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

53

Fundamental Machine Learning Algorithms

We’ll use an objective metric that tells us how good the current values are. Optimal parameter values will minimize that metric. The most used metric in such cases is Mean Squared Error(MSE)⁷⁹. It is defined as: 1 ∑ (i) (y − fw,b (x(i) ))2 m i=1 m

M SE = L(x) =

The MSE measures how much the average model predictions vary from the correct values. The number is higher when the model is making “bad” predictions. Model that makes perfect predictions has a MSE of 0. We’ve transformed the problem of finding optimal values for our parameters to minimizing MSE. We can do that using an optimization algorithm known as Stochastic Gradient Descent⁸⁰.

Simple Linear Regression This type of Linear Regression uses a single feature to predict the target variable. Let’s use the horsepower to predict car acceleration: 1

from sklearn.linear_model import LinearRegression

2 3

X, y = create_regression_dataset(auto_df, columns=['horsepower'])

4 6

reg = LinearRegression() eval_regressor(reg, X, y)

1

0.5283214994429212

5

Multiple Linear Regression Of course, we can use more features to predict the acceleration. This is called Multiple Linear Regression. The training process looks identical (thanks to the nice interface that scikit-learn⁸¹ provides):

⁷⁹https://en.wikipedia.org/wiki/Mean_squared_error ⁸⁰https://en.wikipedia.org/wiki/Stochastic_gradient_descent ⁸¹https://scikit-learn.org/stable/ You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Fundamental Machine Learning Algorithms 1

54

X, y = create_regression_dataset(auto_df)

2 4

reg = LinearRegression() eval_regressor(reg, X, y)

1

0.4351523357394419

3

The $R^2$ score has increased. Can we do better? How?

Ridge Regression 1

from sklearn.linear_model import Ridge

2 3

X, y = create_regression_dataset(auto_df)

4 5

reg = Ridge(alpha=0.0005, random_state=RANDOM_SEED)

6 7

eval_regressor(reg, X, y)

1

0.4351510356810997

When To Use Linear Regression? Start with this algorithm when starting a regression problem. Useful when your features can be separated by a straight line. Pros: • Fast to train on large datasets • Fast inference time • Easy to understand/interpret the results Cons: • Need to scale numerical features • Preprocess categorical data • Can predict only linear relationships

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

55

Fundamental Machine Learning Algorithms

Logistic Regression Logistic Regression⁸² has a similar formulation to Linear Regression (hence the name) but allows you to solve classification problems. The most common problem solved in practice is binary classification, so we’ll discuss this application in particular.

Making Predictions We already have a way to make predictions with Linear Regression. The problem is that they are in (−∞, +∞) interval. How can you use that to make true/false predictions? If we map false to 0 and true to 1, we can use the Sigmoid function⁸³ to bound the domain to (0, 1). It is defined by: f (x) =

1 1 + e−x

⁸²https://en.wikipedia.org/wiki/Logistic_regression ⁸³https://en.wikipedia.org/wiki/Sigmoid_function

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

56

Fundamental Machine Learning Algorithms

We can use the Sigmoid function and a predefined threshold ( commonly set to 0.5) to map values larger than the threshold to a positive label; otherwise, it’s negative. Combining the Linear Regression equation with the Sigmoid function gives us: fw,b (x) =

1 1+

e−(wx+b)

Your next task is to find optimal parameter values for w∗ and b∗ . We can use the Log Loss⁸⁴ to measure how good our classifications are: 1 ∑ [yi log fw,b (x) + (1 − yi ) log (1 − fw,b (x))] m i=1 m

Log Loss = L(x) = −

Our goal is to minimize the loss value. So, a value close to 0 says that the classifier is very good at predicting on the dataset. Logg Loss requires that your classifier outputs probability for each possible class, instead of just the most likely one. Ideal classifier assigns a probability equal to 1 for the correct class and 0 for all else. Just as with Linear Regression, we can use Gradient Descent to find the optimal parameters for our model. How can we do it with scikit-learn? ⁸⁴http://wiki.fast.ai/index.php/Log_Loss

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Fundamental Machine Learning Algorithms

57

Example The LogisticRegression⁸⁵ from scikit-learn allows you to do multiclass classification. It also applies l2 regularization by default. Let’s use it to predict car model origin: 1

from sklearn.linear_model import LogisticRegression

2 3

X, y = create_classification_dataset(auto_df)

4 6

clf = LogisticRegression(solver="lbfgs") eval_classifier(clf, X, y)

1

0.787948717948718

5

We got about ∼79% accuracy, which is quite good, considering how simple the model is.

When To Use It? Logistic Regression should be your first choice when solving a new classification problem. Pros: • Easy to understand and interpret • Easy to configure (small number of hyperparameters) • Outputs the likelihood for each class Cons: • Requires data scaling • Assumes linear relationship in the data • Sensitive to outliers

k-Nearest Neighbors During training, this algorithm stores the data in some sort of efficient data structure (like k-d tree⁸⁶), so it is available for later. Predictions are made by finding k (hence the name) similar training examples and returning the most common label (in case of classification) or avering label values (in case of regression). How do we measure similarity? ⁸⁵https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html ⁸⁶https://en.wikipedia.org/wiki/K-d_tree You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

58

Fundamental Machine Learning Algorithms

Measuring the similarity of two data points is most commonly done by measuring the distance between them. Some of the most popular distance measures are Euclidean Distance⁸⁷: v u n u∑ Eucleadian Distance(a, b) = t (ai − bi )2 i=1

measures the straight-line distance between two points in Euclidean space and Cosine Similarity⁸⁸: n ∑

ai bi √ Cosine Similarity(a, b) = √ n n ∑ ∑ 2 ai b2i i=1

i=1

i=1

which measures how similar the directions of two vectors are. You might think that normalizing features is really important for this algorithm, and you’ll be right! ⁸⁷https://en.wikipedia.org/wiki/Euclidean_distance ⁸⁸https://en.wikipedia.org/wiki/Cosine_similarity

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Fundamental Machine Learning Algorithms

59

Example k-Nearest Neighbors (KNN) can be used for classification and regression tasks. KNeighborsClassifier⁸⁹ offers a nice set of options for parameters like - number of neighbors and the type of metric to use. Let’s look at an example: 1

from sklearn.neighbors import KNeighborsClassifier

2 3

X, y = create_classification_dataset(auto_df)

4 6

clf = KNeighborsClassifier(n_neighbors=24) eval_classifier(clf, X, y)

1

0.8008333333333335

5

How can you find good values for k (number of neighbors)? Usually, you just try a lot of different values.

When To Use It? This algorithm might have very good performance when compared to Linear Regression. It works quite well on smallish datasets with not that many features. Pros: • • • •

Easy to understand and reason about Trains instantly (all of the work is done when predicting data) Makes no assumption about input data distributions Automatically adjusts predictions as new data comes in

Cons: • Need to scale numerical features (depends on distance measurements) • Slow inference time (all of the work is done when predicting data) • Sensitive to imbalanced datasets - values occuring more often will bias the results. You can use resampling techniques for this issue. • High dimensional features may produce closeness to many data points. You can apply dimensionality reduction techniques for this issue. ⁸⁹https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

60

Fundamental Machine Learning Algorithms

Naive Bayes Naive Bayes⁹⁰ algorithms calculate the likelihood of each class is correct. They apply Bayes’ theorem to classification problems. That is, with a strong (and often unrealistic) assumption of independence between the features.

Bayes Theorem Bayes theorem⁹¹ gives the following relationship between the labels and features: P (y | x1 , . . . , xn ) =

P (x1 , . . . , xn | y)P (y) P (x1 , . . . , xn )

Using the independence assumption we get: P (y | x1 , . . . , xn ) =

∏n P (y) i=1 P (xi |y) P (x1 , . . . , xn )

P (x1 , . . . , xn ) is a normalizing term (constant). We can drop it, since we’re interested in the most

probable hypothesis, and use the following classification rule: ⁹⁰https://en.wikipedia.org/wiki/Naive_Bayes_classifier ⁹¹https://en.wikipedia.org/wiki/Bayes%27_theorem You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

61

Fundamental Machine Learning Algorithms

yˆ = arg max P (y) y

n ∏

P (xi | y)

i=1

Example Scikit-learn implements multiple Naive Bayes classifiers. We’re going to use GaussianNB⁹² which assumes Gaussian distribution of the data: 1

from sklearn.naive_bayes import GaussianNB

2 3

X, y = create_classification_dataset(auto_df)

4 6

clf = GaussianNB() eval_classifier(clf, X, y)

1

0.7597435897435898

5

When To Use It? Naive Bayes classifiers are a very good choice for building baseline models that have a probabilistic interpretation of its outputs. Training and prediction speed are very good on large amounts of data. Pros: • • • • •

Fast training and inference performance Can be easily interpreted due to probabilistic predictions Easy to tune (a few hyperparameters) No feature scaling required Can handle imbalanced datasets - with Complement Naive Bayes

Cons: • Naive assumption about independence, which is rarely true (duh) • Performance suffers when multicollinearity⁹³ is present ⁹²https://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html#sklearn.naive_bayes.GaussianNB ⁹³https://en.wikipedia.org/wiki/Multicollinearity

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Fundamental Machine Learning Algorithms

62

Decision Trees Decision Tree algorithms build (mostly binary) trees using the data to choose split points. At each node, a specific feature is examined and compared to a threshold. We go to the left if the value is below the threshold, else we go right. We get an answer (prediction) of the model when a leaf node is reached.

Example Scikit-learn offers multiple tree-based algorithms for both regression and classification. Let’s look at an example: 1

from sklearn.tree import DecisionTreeRegressor

2 3

X, y = create_regression_dataset(auto_df)

4 5 6

reg = DecisionTreeRegressor() eval_regressor(reg, X, y)

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Fundamental Machine Learning Algorithms 1

63

0.6529188972733717

Random Forests The Random Forest algorithm combines multiple decision trees. Each tree is trained on a random subset of the data and has a low bias (low error on the training data) and high variance (high error on the test data). Aggregating the trees allows you to build a model with low variance. 1

from sklearn.ensemble import RandomForestRegressor

2 3

X, y = create_regression_dataset(auto_df)

4 6

reg = RandomForestRegressor(n_estimators=50) eval_regressor(reg, X, y)

1

0.3976871715935767

5

Note the error difference between a single Decision Tree and a Random Forest with 50 weak Decision Trees.

Boosting This method builds multiple decision trees iteratively. Each new tree tries to fix the errors made by the previous one. At each step, the error between the predicted and actual data is added to the loss and then minimized at the next step. 1

from sklearn.ensemble import GradientBoostingRegressor

2 3

X, y = create_regression_dataset(auto_df)

4 6

reg = GradientBoostingRegressor(n_estimators=100) eval_regressor(reg, X, y)

1

0.37605497373246266

5

Now go to Kaggle⁹⁴ and check how many competitions are won by using this method. ⁹⁴https://www.kaggle.com/

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Fundamental Machine Learning Algorithms

64

When To Use It? In practice, you’ll never be using a single Decision Tree. Ensemble methods (multiple decision trees) are the way to go. Overall, boosting can give you the best possible results (especially when using libraries like LightGBM⁹⁵). But you have a lot of hyperparameters to tune. It might take a lot of time and experience to develop really good models. Pros: • • • • • • •

Easy to interpret and visualize (white box models) Can handle numerical and categorical data No complex data preprocessing - no normalization or missing data imputation is need Fast prediction speed - O(log n) Can be used in ensembles to prevent overfitting and increase accuracy Perform very well on both regression and classification tasks Show feature importances

Cons: • Do not work well with imbalanced datasets - fixed by balancing or providing class weights • Easy to overfit - you can build very deep trees that memorize every feature value - fixed by limiting tree depth • Must be used in ensembles to get good results in practice • Sensitive to data changes (small variation can build entirely different tree) - fixed using ensembles

Support Vector Machines (SVM) SVM models try to build hyperplanes (n-dimensional lines) that best separate the data. Hyperplanes are created such that there is a maximum distance between the closest example of each class. ⁹⁵https://github.com/microsoft/LightGBM

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

65

Fundamental Machine Learning Algorithms

Hard-margin Hard-margin SVMs⁹⁶ work when the data is linearly separable. We want to minimize the margin between the support vectors ∥w∥ (the closest data points to the separating hyperplane). We have: 1 2

min ∥w∥2 satisfying the constraint: yi (wxi − b) − 1 ≥ 0, i = 1, . . . , n

What about data points that cannot be linearly separated?

Soft-margin In practice, the expectation that the data is linearly separable is unrealistic. We can cut some slack to our SVM and introduce a constant C . It determines the tradeoff between increasing the decision boundary and placing each data point on the correct side of the decision boundary. We want to minimize the following function: 1∑ max(0, 1 − yi (wxi − b)) n i=1 n

2

C∥w∥ +

⁹⁶https://en.wikipedia.org/wiki/Support-vector_machine#Hard-margin You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Fundamental Machine Learning Algorithms

66

Choosing the correct C is done experimentally. You can look at this parameter as a way to control the bias-variance tradeoff for your model.

Example Using SVMs on regression problems can be done using the SVR⁹⁷ model: 1

from sklearn.svm import SVR

2 3

X, y = create_regression_dataset(auto_df)

4 6

reg = SVR(gamma="auto", kernel="rbf", C=4.5) eval_regressor(reg, X, y)

1

0.32820308689067834

5

When To Use It? Support Vector Machines can give you great performance but need careful tuning. You can solve non-linearly separable problems with a proper choice of a kernel function. Pros: • Can provide very good results used for regression and classification • Can learn non-linear boundaries (see the kernel trick⁹⁸) • Robust to overfitting in higher dimensional space Cons: • • • •

Large number of hyperparameters Data must be scaled Data must be balanced Sensitive to outliers - can be mitigated by using soft-margin

⁹⁷https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html ⁹⁸https://en.wikipedia.org/wiki/Kernel_method#Mathematics:_the_kernel_trick

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Fundamental Machine Learning Algorithms

67

Conclusion You covered some of the most used Machine Learning algorithms. But you’ve just scratched the surface. Devil is in the details, and those algorithms have a lot of details surrounding them. You learned about: • • • • • •

Linear Regression Logistic Regression k-Nearest Neighbors Naive Bayes Decision Trees Support Vector Machines

I find it fascinating that there are no clear winners when it comes to having an all-around best algorithm. Your project/problem will inevitably require some careful experimentation and planning. Enjoy the process :) Run the complete notebook in your browser⁹⁹ The complete project on GitHub¹⁰⁰

References • Machine Learning Notation¹⁰¹ • Making Sense of Logarithmic Loss¹⁰² • In Depth: Naive Bayes Classification¹⁰³ ⁹⁹https://colab.research.google.com/drive/1-_wQbYW-KqDNMkT9iZ-d2KWVHyR6d0nn ¹⁰⁰https://github.com/curiousily/Deep-Learning-For-Hackers ¹⁰¹https://nthu-datalab.github.io/ml/slides/Notation.pdf ¹⁰²https://datawookie.netlify.com/blog/2015/12/making-sense-of-logarithmic-loss/ ¹⁰³https://jakevdp.github.io/PythonDataScienceHandbook/05.05-naive-bayes.html

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Data Preprocessing TL;DR Learn how to do feature scaling, handle categorical data and do feature engineering with Pandas and Scikit-learn in Python. Use your skills to preprocess a housing dataset and build a model to predict prices. I know, data preprocessing might not sound cool. You might just want to train Deep Neural Networks (or your favorite models). I am here to shatter your dreams, you’ll most likely spend a lot more time on data preprocessing and exploration¹⁰⁴ than any other step of your Machine Learning workflow. Since this step is so early in the process, screwing up here will lead to useless models. Garbage data in, garbage predictions out. A requirement for reaching your model’s full potential is proper cleaning, wrangling and analysis of the data. This guide will introduce you to the most common and useful methods to preprocess your data. We’re going to look at three general techniques: • Feature Scaling • Handling Categorical Data • Feature Engineering Finally, we’re going to apply what we’ve learned on a real dataset and try to predict Melbourne housing prices. We’re going to compare the performance of a model with and without data preprocessing. How improtant data preparation really is? Run the complete notebook in your browser¹⁰⁵ The complete project on GitHub¹⁰⁶

Feature Scaling Feature scaling¹⁰⁷ refers to the process of changing the range (normalization) of numerical features. There are different methods to do feature scaling. But first, why do you need to do it? When Machine Learning algorithms measure distances between data points, the results may be dominated by the magnitude (scale) of the features instead of their values. Scaling the features to a ¹⁰⁴https://www.forbes.com/sites/gilpress/2016/03/23/data-preparation-most-time-consuming-least-enjoyable-data-science-task-surveysays/#305db5686f63 ¹⁰⁵https://colab.research.google.com/drive/1c61XEZ7MHKFDcBOX87Wx1SNrtNYAF6Zt ¹⁰⁶https://github.com/curiousily/Deep-Learning-For-Hackers ¹⁰⁷https://en.wikipedia.org/wiki/Feature_scaling

69

Data Preprocessing

similar range can fix the problem. Gradient Descent¹⁰⁸ can converge faster¹⁰⁹ when feature scaling is applied. Use feature scaling when your algorithm calculates distances or is trained with Gradient Descent How can we do feature scaling? Scikit-learn¹¹⁰ offers a couple of methods. We’ll use the following synthetic data to compare them: 1 2 3 4 5

data = pd.DataFrame({ 'Normal': np.random.normal(100, 50, 1000), 'Exponential': np.random.exponential(25, 1000), 'Uniform': np.random.uniform(-150, -50, 1000) })

Min-Max Normalization One of the simplest and most widely used approaches is to scale each feature in the [0, 1] range. The scaled value is given by: x′ =

x – min(x) max(x) – min(x)

MinMaxScaler¹¹¹ allows you to select the rescale range with the feature_range parameter: 1

from sklearn.preprocessing import MinMaxScaler

2 3

min_max_scaled = MinMaxScaler(feature_range=(0, 1)).fit_transform(data) ¹⁰⁸https://en.wikipedia.org/wiki/Gradient_descent ¹⁰⁹https://arxiv.org/abs/1502.03167 ¹¹⁰https://scikit-learn.org/stable/modules/classes.html#module-sklearn.preprocessing ¹¹¹https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

70

Data Preprocessing

The scaled distributions do not overlap as much and their shape remains the same (except for the Normal). This method preserves the shape of the original distribution and is sensitive to outliers.

Standardization This method rescales a feature removing the mean and divides by standard deviation. It produces a distribution centered at 0 with a standard deviation of 1. Some Machine Learning algorithms (SVMs) assume features are in this range. It is defined by: x′ =

x − mean(x)

stdev(x)

You can use the StandarScaler¹¹² like this:

¹¹²https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

71

Data Preprocessing 1

from sklearn.preprocessing import StandardScaler

2 3

stand_scaled = StandardScaler().fit_transform(data)

The resulting distributions overlap heavily. Also, their shape is much narrower. This method “makes” a feature normally distributed. With outliers, your data will be scaled to a small interval.

Robust Scaling This method is very similar to the Min-Max approach. Each feature is scaled with: X=

x − Q1 (x) Q3 (x) − Q1 (x)

where Q are quartiles. The Interquartile range¹¹³ makes this method robust to outliers (hence the name). Let’s use the RobustScaler¹¹⁴ on our data: ¹¹³https://en.wikipedia.org/wiki/Interquartile_range ¹¹⁴https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.RobustScaler.html You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

Data Preprocessing 1

from sklearn.preprocessing import RobustScaler

2 3

robust_scaled = RobustScaler().fit_transform(data)

All distributions have most of their densities around 0 and a shape that is more or less the same. Use this method when you have outliers and want to minimize their influence.

Scaling Methods Overview Here’s an overview of the scaled distributions compared to the non-scaled version:

You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

72

Data Preprocessing

73

Handling Categorical Data Categorical variables (also known as nominal¹¹⁵) are a set of enumerable values. They cannot be numerically organized or ranked. How can we use them in our Machine Learning algorithms? Some algorithms, like decision trees, will work fine without any categorical data preprocessing. Unfortunatelly, that is the exception rather than the rule. How can we encode the following property types? 1 2 3

property_type =\ np.array(['House', 'Unit', 'Townhouse', 'House', 'Unit']) .reshape(-1, 1)

Integer Encoding Most Machine Learning algorithms require numeric-only data. One simple way to achieve that is to assing an unique value to each category. We can use the OrdinalEncoder¹¹⁶ for that: ¹¹⁵https://en.wikipedia.org/wiki/Nominal_category ¹¹⁶https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OrdinalEncoder.html You are totally awesome! Find me at https://www.curiousily.com/ if you have questions.

74

Data Preprocessing 1

from sklearn.preprocessing import OrdinalEncoder

2

5

enc = OrdinalEncoder().fit(property_type) labels = enc.transform(property_type) labels.flatten()

1

array([0., 2., 1., 0., 2.])

3 4

You can obtain the string representation of the categories like so: 1

enc.inverse_transform(one_hots).flatten()

1

array(['House', 'Unit', 'Townhouse', 'House', 'Unit'], dtype='