Grokking Machine Learning

Machine Learning
contents
foreword
preface
acknowledgments
about this book
How this book is organized: A roadmap
About the code
liveBook discussion forum
about the author
1 What is machine learning? It is common sense, except done by a computer
I am super happy to join you in your learning journey!
Machine learning is everywhere
Do I need a heavy math and coding background to understand machine learning?
Formulas and code are fun when seen as a language
OK, so what exactly is machine learning?
What is artificial intelligence?
What is machine learning?
And now that we’re at it, what is deep learning?
How do we get machines to make decisions with data? The remember-formulate-predict framework
How do humans think?
Some machine learning lingo-models and algorithms
Some examples of models that humans use
Some examples of models that machines use
Summary
2 Types of machine learning
What is the difference between labeled and unlabeled data?
What is data?
And what are features?
Labels?
Predictions
Labeled and unlabeled data
Supervised learning: The branch of machine learning that works with labeled data
Regression models predict numbers
Classification models predict a state
Unsupervised learning: The branch of machine learning that works with unlabeled data
Clustering algorithms split a dataset into similar groups
Dimensionality reduction simplifies data without losing too much information
Other ways of simplifying our data: Matrix factorization and singular value decomposition
Generative machine learning
What is reinforcement learning?
Summary
Exercises
3 Drawing a line close to our points: Linear regression
The problem: We need to predict the price of a house
The solution: Building a regression model for housing prices
The remember step: Looking at the prices of existing houses
The formulate step: Formulating a rule that estimates the price of the house
The predict step: What do we do when a new house comes on the market?
What if we have more variables? Multivariate linear regression
Some questions that arise and some quick answers
How to get the computer to draw this line: The linear regression algorithm
Crash course on slope and y-intercept
A simple trick to move a line closer to a set of points, one point at a time
The square trick: A much more clever way of moving our line closer to one of the points
The absolute trick: Another useful trick to move the line closer to the points
The linear regression algorithm: Repeating the absolute or square trick many times to move the line
Loading our data and plotting it
Using the linear regression algorithm in our dataset
Using the model to make predictions
The general linear regression algorithm (optional)
How do we measure our results? The error function
The absolute error: A metric that tells us how good our model is by adding distances
The square error: A metric that tells us how good our model is by adding squares of distances
Mean absolute and (root) mean square errors are more common in real life
Gradient descent: How to decrease an error function by slowly descending from a mountain
Plotting the error function and knowing when to stop running the algorithm
Do we train using one point at a time or many? Stochastic and batch gradient descent
Real-life application: Using Turi Create to predict housing prices in India
What if the data is not in a line? Polynomial regression
A special kind of curved functions: Polynomials
Nonlinear data? No problem: Let’s try to fit a polynomial curve to it
Parameters and hyperparameters
Applications of regression
Recommendation systems
Video and music recommendations
Product recommendations
Health care
Summary
Exercises
4 Optimizing the training process: Underfitting, overfitting, testing, and regularization
An example of underfitting and overfitting using polynomial regression
How do we get the computer to pick the right model? By testing
How do we pick the testing set, and how big should it be?
Can we use our testing data for training the model? No.
Where did we break the golden rule, and how do we fix it? The validation set
A numerical way to decide how complex our model should be: The model complexity graph
Another alternative to avoiding overfitting: Regularization
Another example of overfitting: Movie recommendations
Measuring how complex a model is: L1 and L2 norm
Modifying the error function to solve our problem: Lasso regression and ridge regression
Regulating the amount of performance and complexity in our model: The regularization parameter
Effects of L1 and L2 regularization in the coefficients of the model
An intuitive way to see regularization
Polynomial regression, testing, and regularization with Turi Create
Summary
Exercises
5 Using lines to split our points: The perceptron algorithm
The problem: We are on an alien planet, and we don’t know their language!
A slightly more complicated planet
Does our classifier need to be correct all the time? No
A more general classifier and a slightly different way to define lines
The step function and activation functions: A condensed way to get predictions
What happens if I have more than two words? General definition of the perceptron classifier
The bias, the y-intercept, and the inherent mood of a quiet alien
How do we determine whether a classifier is good or bad? The error function
How to compare classifiers? The error function
How to find a good classifier? The perceptron algorithm
The perceptron trick: A way to slightly improve the perceptron
Repeating the perceptron trick many times: The perceptron algorithm
Gradient descent
Stochastic and batch gradient descent
Coding the perceptron algorithm
Coding the perceptron trick
Coding the perceptron algorithm
Coding the perceptron algorithm using Turi Create
Applications of the perceptron algorithm
Spam email filters
Recommendation Systems
Health care
Computer vision
Summary
Exercises
6 A continuous approach to splitting points: Logistic classifiers
Logistic classifiers: A continuous version of perceptron classifiers
A probability approach to classification: The sigmoid function
The dataset and the predictions
The error functions: Absolute, square, and log loss
Comparing classifiers using the log loss
How to find a good logistic classifier? The logistic regression algorithm
The logistic trick: A way to slightly improve the continuous perceptron
Repeating the logistic trick many times: The logistic regression algorithm
Stochastic, mini-batch, and batch gradient descent
Coding the logistic regression algorithm
Coding the logistic regression algorithm by hand
Real-life application: Classifying IMDB reviews with Turi Create
Classifying into multiple classes: The softmax function
Summary
Exercises
7 How do you measure classification models? Accuracy and its friends
Accuracy: How often is my model correct?
Two examples of models: Coronavirus and spam email
A super effective yet super useless model
How to fix the accuracy problem? Defining different types of errors and how to measure them
False positives and false negatives: Which one is worse?
Storing the correctly and incorrectly classified points in a table: The confusion matrix
Recall: Among the positive examples, how many did we correctly classify?
Precision: Among the examples we classified as positive, how many did we correctly classify?
Combining recall and precision as a way to optimize both: The F-score
Recall, precision, or F-scores: Which one should we use?
A useful tool to evaluate our model: The receiver operating characteristic (ROC) curve
Sensitivity and specificity: Two new ways to evaluate our model
The receiver operating characteristic (ROC) curve: A way to optimize sensitivity and specificity in
A metric that tells us how good our model is: The AUC (area under the curve)
How to make decisions using the ROC curve
Recall is sensitivity, but precision and specificity are different
Summary
Exercises
8 Using probability to its maximum: The naive Bayes model
Sick or healthy? A story with Bayes’ theorem as the hero
Prelude to Bayes’ theorem: The prior, the event, and the posterior
Use case: Spam-detection model
Finding the prior: The probability that any email is spam
Finding the posterior: The probability that an email is spam, knowing that it contains a particular
What the math just happened? Turning ratios into probabilities
What about two words? The naive Bayes algorithm
What about more than two words?
Building a spam-detection model with real data
Data preprocessing
Finding the priors
Finding the posteriors with Bayes’ theorem
Implementing the naive Bayes algorithm
Further work
Summary
Exercises
9 Splitting data by asking questions: Decision trees
The problem: We need to recommend apps to users according to what they are likely to download
The solution: Building an app-recommendation system
First step to build the model: Asking the best question
Second step to build the model: Iterating
Last step: When to stop building the tree and other hyperparameters
The decision tree algorithm: How to build a decision tree and make predictions with it
Beyond questions like yes/no
Splitting the data using non-binary categorical features, such as dog/cat/bird
Splitting the data using continuous features, such as age
The graphical boundary of decision trees
Using Scikit-Learn to build a decision tree
Real-life application: Modeling student admissions with Scikit-Learn
Setting hyperparameters in Scikit-Learn
Decision trees for regression
Applications
Decision trees are widely used in health care
Decision trees are useful in recommendation systems
Summary
Exercises
10 Combining building blocks to gain more power: Neural networks
Neural networks with an example: A more complicated alien planet
Solution: If one line is not enough, use two lines to classify your dataset
Why two lines? Is happiness not linear?
Combining the outputs of perceptrons into another perceptron
A graphical representation of perceptrons
A graphical representation of neural networks
The boundary of a neural network
The general architecture of a fully connected neural network
Training neural networks
Error function: A way to measure how the neural network is performing
Backpropagation: The key step in training the neural network
Potential problems: From overfitting to vanishing gradients
Techniques for training neural networks: Regularization and dropout
Different activation functions: Hyperbolic tangent (tanh) and the rectified linear unit (ReLU)
Neural networks with more than one output: The softmax function
Hyperparameters
Coding neural networks in Keras
A graphical example in two dimensions
Training a neural network for image recognition
Neural networks for regression
Other architectures for more complex datasets
How neural networks see: Convolutional neural networks (CNN)
How neural networks talk: Recurrent neural networks (RNN), gated recurrent units (GRU), and long sho
How neural networks paint paintings: Generative adversarial networks (GAN)
Summary
Exercises
11 Finding boundaries with style: Support vector machines and the kernel method
Using a new error function to build better classifiers
Classification error function: Trying to classify the points correctly
Distance error function: Trying to separate our two lines as far apart as possible
Adding the two error functions to obtain the error function
Do we want our SVM to focus more on classification or distance? The C parameter can help us
Coding support vector machines in Scikit-Learn
Coding a simple SVM
The C parameter
Training SVMs with nonlinear boundaries: The kernel method
Using polynomial equations to our benefit: The polynomial kernel
Using bumps in higher dimensions to our benefit: The radial basis function (RBF) kernel
Training an SVM with the RBF kernel
Coding the kernel method
Summary
Exercises
12 Combining models to maximize results: Ensemble learning
With a little help from our friends
Bagging: Joining some weak learners randomly to build a strong learner
Fitting a random forest manually
Training a random forest in Scikit-Learn
AdaBoost: Joining weak learners in a clever way to build a strong learner
A big picture of AdaBoost: Building the weak learners
Combining the weak learners into a strong learner
Coding AdaBoost in Scikit-Learn
Gradient boosting: Using decision trees to build strong learners
XGBoost: An extreme way to do gradient boosting
XGBoost similarity score: A new and effective way to measure similarity in a set
Building the weak learners
Tree pruning: A way to reduce overfitting by simplifying the weak learners
Making the predictions
Training an XGBoost model in Python
Applications of ensemble methods
Summary
Exercises
13 Putting it all in practice: A real-life example of data engineering and machine learning
The Titanic dataset
The features of our dataset
Using Pandas to load the dataset
Using Pandas to study our dataset
Cleaning up our dataset: Missing values and how to deal with them
Dropping columns with missing data
How to not lose the entire column: Filling in missing data
Feature engineering: Transforming the features in our dataset before training the models
Turning categorical data into numerical data: One-hot encoding
Turning numerical data into categorical data (and why would we want to do this?): Binning
Feature selection: Getting rid of unnecessary features
Training our models
Splitting the data into features and labels, and training and validation
Training several models on our dataset
Which model is better? Evaluating the models
Testing the model
Tuning the hyperparameters to find the best model: Grid search
Using K-fold cross-validation to reuse our data as training and validation
Summary
Exercises
Appendix A: Solutions to the exercises
Chapter 2: Types of machine learning
Exercise 2.1
Exercise 2.2
Exercise 2.3
Chapter 3: Drawing a line close to our points: Linear regression
Exercise 3.1
Exercise 3.2
Exercise 3.3
Exercise 3.4
Chapter 4: Optimizing the training process: Underfitting, overfitting, testing, and regularization
Exercise 4.1
Exercise 4.2
Chapter 5: Using lines to split our points: The perceptron algorithm
Exercise 5.1
Exercise 5.2
Exercise 5.3
Chapter 6: A continuous approach to splitting points: Logistic classifiers
Exercise 6.1
Exercise 6.2
Exercise 6.3
Chapter 7: How do you measure classification models? Accuracy and its friends
Exercise 7.1
Exercise 7.2
Exercise 7.3
Exercise 7.4
Chapter 8: Using probability to its maximum: The naive Bayes model
Exercise 8.1
Exercise 8.2
Exercise 8.3
Chapter 9: Splitting data by asking questions: Decision trees
Exercise 9.1
Exercise 9.2
Exercise 9.3
Chapter 10: Combining building blocks to gain more power: Neural networks
Exercise 10.1
Exercise 10.2
Exercise 10.3
Chapter 11: Finding boundaries with style: Support vector machines and the kernel method
Exercise 11.1
Exercise 11.2
Chapter 12: Combining models to maximize results: Ensemble learning
Exercise 12.1
Exercise 12.2
Chapter 13: Putting it all in practice: A real-life example of data engineering and machine learning
Exercise 13.1
Appendix B: The math behind gradient descent: Coming down a mountain using derivatives and slopes
Using gradient descent to decrease functions
Using gradient descent to train models
Using gradient descent to train linear regression models
Using gradient descent to train classification models
Using gradient descent to train neural networks
Using gradient descent for regularization
Getting stuck on local minima: How it happens, and how we solve it
Appendix C: References
General references
Courses
Blogs and YouTube channels
Books
Chapter 1
Videos
Chapter 2
Videos
Books
Courses
Chapter 3
Code
Datasets
Videos
Chapter 4
Code
Videos
Chapter 5
Code
Videos
Chapter 6
Code
Datasets
Videos
Chapter 7
Videos
Chapter 8
Code
Datasets
Visibility: Public Videos
Chapter 9
Code
Datasets
Videos
Blog post
Chapter 10
Code
Datasets
Videos
Books
Courses
Blog posts
Tools
Chapter 11
Code
Videos
Blog posts
Chapter 12
Code
Videos
Articles and blog posts
Chapter 13
Code
Datasets
Graphics and image icons
index
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
R
S
T
U
V
W
X