## Machine Learning Algorithms Every Data Scientist Should Know

### Types Of ML Algorithms

There are a huge number of ML algorithms out there. Trying to classify them leads to the distinction being made in types of the training procedure, applications, the latest advances, and some of the standard algorithms used by ML scientists in their daily work. There is a lot to cover, and we shall proceed as given in the following listing:

- Statistical Algorithms
- Classification
- Regression
- Clustering
- Dimensionality Reduction
- Ensemble Algorithms
- Deep Learning
- Reinforcement Learning
- AutoML (Bonus)

### 1. Statistical Algorithms

**Statistics** is necessary for every machine learning expert. Hypothesis testing and confidence intervals are some of the many statistical concepts to know if you are a data scientist. Here, we consider here the phenomenon of **overfitting. **Basically, overfitting occurs when an ML model learns so many features of the training data set that the generalization capacity of the model on the test set takes a toss. The tradeoff between performance and overfitting is well illustrated by the following illustration:

Here, the black curve represents the performance of a classifier that has appropriately classified the dataset into two categories. Obviously, training the classifier was stopped at the right time in this instance. The green curve indicates what happens when we allow the training of the classifier to ‘overlearn the features’ in the training set. What happens is that we get an accuracy of 100%, but we lose out on performance on the test set because the test set will have a feature boundary that is usually similar but definitely not the same as the training set. This will result in a high error level when the classifier for the green curve is presented with new data. How can we prevent this?

### Cross-Validation

**Cross-Validation** is the killer technique used to avoid overfitting. How does it work? A visual representation of the k-fold cross-validation process is given below:

The entire dataset is split into equal subsets and the model is trained on all possible combinations of training and testing subsets that are possible as shown in the image above. Finally, the average of all the models is combined. The advantage of this is that this method eliminates sampling error, prevents overfitting, and accounts for bias. There are further variations of cross-validation like non-exhaustive cross-validation and nested k-fold cross validation (shown above). For more on cross-validation, visit the following link.

There are many more statistical algorithms that a data scientist has to know. Some examples include the chi-squared test, the Student’s t-test, how to calculate confidence intervals, how to interpret p-values, advanced probability theory, and many more. For more, please visit the excellent article given below:

### 2. Classification Algorithms

**Classification** refers to the process of categorizing data input as a member of a target class. An example could be that we can classify customers into low-income, medium-income, and high-income depending upon their spending activity over a financial year. This knowledge can help us tailor the ads shown to them accurately when they come online and maximises the chance of a conversion or a sale. There are various types of classification like binary classification, multi-class classification, and various other variants. It is perhaps the most well known and most common of all data science algorithm categories. The algorithms that can be used for classification include:

- Logistic Regression
- Support Vector Machines
- Linear Discriminant Analysis
- K-Nearest Neighbours
- Decision Trees
- Random Forests

and many more. A short illustration of a binary classification visualization is given below:

For more information on classification algorithms, refer to the following excellent links:

How to train a decision tree classifier for churn prediction

### 3. Regression Algorithms

**Regression** is similar to classification, and many algorithms used are similar (e.g. random forests). The difference is that while classification categorizes a data point, regression predicts a continuous real-number value. So classification works with classes while regression works with real numbers. And yes – many algorithms can be used for both classification and regression. Hence the presence of logistic regression in both lists. Some of the common algorithms used for regression are

- Linear Regression
- Support Vector Regression
- Logistic Regression
- Ridge Regression
- Partial Least-Squares Regression
- Non-Linear Regression

For more on regression, I suggest that you visit the following link for an excellent article:

Multiple Linear Regression & Assumptions of Linear Regression: A-Z

Another article you can refer to is:

Both articles have a remarkably clear discussion of the statistical theory that you need to know to understand regression and apply it to non-linear problems. They also have **source code** in Python and R that you can use.

### 4. Clustering

**Clustering** is an unsupervised learning algorithm category that divides the data set into groups depending upon common characteristics or common properties. A good example would be grouping the data set instances into categories automatically, the process being used would be any of several algorithms that we shall soon list. For this reason, clustering is sometimes known as automatic classification. It is also a critical part of exploratory data analysis (EDA). Some of the algorithms commonly used for clustering are:

- Hierarchical Clustering – Agglomerative
- Hierarchical Clustering – Divisive
- K-Means Clustering
- K-Nearest Neighbours Clustering
- EM (Expectation Maximization) Clustering
- Principal Components Analysis Clustering (PCA)

An example of a common clustering problem visualization is given below:

The above visualization clearly contains three clusters.

Another excellent article on clustering refer the link

You can also refer to the following article:

### 5. Dimensionality Reduction

**Dimensionality Reduction** is an extremely important tool that should be completely clear and lucid for any serious data scientist. Dimensionality Reduction is also referred to as feature selection or feature extraction. This means that the principal variables of the data set that contains the highest covariance with the output data are extracted and the features/variables that are not important are ignored. It is an essential part of EDA (Exploratory Data Analysis) and is nearly always used in every moderately or highly difficult problem. The advantages of dimensionality reduction are (from Wikipedia):

- It reduces the time and storage space required.
- Removal of multi-collinearity improves the interpretation of the parameters of the machine learning model.
- It becomes easier to visualize the data when reduced to very low dimensions such as 2D or 3D.
- It avoids the curse of dimensionality.

The most commonly used algorithm for dimensionality reduction is Principal Components Analysis or **PCA**. While this is a linear model, it can be converted to a non-linear model through a kernel trick similar to that used in a Support Vector Machine, in which case the technique is known as Kernel PCA. Thus, the algorithms commonly used are:

- Principal Component Analysis (PCA)
- Non-Negative Matrix Factorization (NMF)
- Kernel PCA
- Linear Discriminant Analysis (LDA)
- Generalized Discriminant Analysis (kernel trick again)

The result of a is visualized below:

You can refer to this article for a general discussion of dimensionality reduction:

This article below gives you a brief description of dimensionality reduction using PCA by coding an ML example:

### 6. Ensembling Algorithms

Ensembling means combining multiple ML learners together into one pipeline so that the combination of all the weak learners makes an ML application with higher accuracy than each learner taken separately. Intuitively, this makes sense, since the disadvantages of using one model would be offset by combining it with another model that does not suffer from this disadvantage. There are various algorithms used in ensembling machine learning models. The three common techniques usually employed in practice are:

**Simple/Weighted Average/Voting:**Simplest one, just takes the vote of models in Classification and average in Regression.**Bagging:**We train models (same algorithm) in parallel for random sub-samples of data-set with replacement. Eventually, take an average/vote of obtained results.**Boosting:**In this models are trained sequentially, where (n)th model uses the output of (n-1)th model and works on the limitation of the previous model, the process stops when result stops improving.**Stacking:**We combine two or more than two models using another machine learning algorithm.

(from **Amardeep Chauhan** on Medium.com)

In all four cases, the combination of the different models ends up having the better performance that one single learner. One particular ensembling technique that has done extremely well on data science competitions on Kaggle is the GBRT model or the Gradient Boosted Regression Tree model.

We include the source code from the scikit-learn module for Gradient Boosted Regression Trees since this is one of the most popular ML models which can be used in competitions like **Kaggle**, **HackerRank**, and **TopCoder**.

Refer Link here

`GradientBoostingClassifier`

supports both binary and multi-class classification. The following example shows how to fit a gradient boosting classifier with 100 decision stumps as weak learners:

1 2 3 4 5 6 7 8 9 10 |
from sklearn.datasets import make_hastie_10_2 from sklearn.ensemble import GradientBoostingClassifier X, y = make_hastie_10_2(random_state=0) X_train, X_test = X[:2000], X[2000:] y_train, y_test = y[:2000], y[2000:] clf = GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0).fit(X_train, y_train) clf.score(X_test, y_test) |

`GradientBoostingRegressor`

supports a number of different loss functions for regression which can be specified via the argument `loss`

; the default loss function for regression is least squares (`'ls'`

).

1 2 3 4 5 6 7 8 9 10 11 |
import numpy as np from sklearn.metrics import mean_squared_error from sklearn.datasets import make_friedman1 from sklearn.ensemble import GradientBoostingRegressor X, y = make_friedman1(n_samples=1200, random_state=0, noise=1.0) X_train, X_test = X[:200], X[200:] y_train, y_test = y[:200], y[200:] est = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=1, random_state=0, loss='ls').fit(X_train, y_train) mean_squared_error(y_test, est.predict(X_test)) |

You can also refer to the following article which discusses Random Forests, which is a (rather basic) ensembling method.

### 7. Deep Learning

In the last decade, there has been a renaissance of sorts within the Machine Learning community worldwide. Since 2002, neural networks research had struck a dead end as the networks of layers would get stuck in local minima in the non-linear hyperspace of the energy landscape of a three layer network. Many thought that neural networks had outlived their usefulness. However, starting with Geoffrey Hinton in 2006, researchers found that adding multiple layers of neurons to a neural network created an energy landscape of such high dimensionality that local minima were statistically shown to be extremely unlikely to occur in practice. Today, in 2019, more than a decade of innovation later, this method of adding addition hidden layers of neurons to a neural network is the classical practice of the field known as **deep learning**.

Deep Learning has truly taken the computing world by storm and has been applied to nearly every field of computation, with great success. Now with advances in Computer Vision, Image Processing, Reinforcement Learning, and Evolutionary Computation, we have marvellous feats of technology like self-driving cars and self-learning expert systems that perform enormously complex tasks like playing the game of Go (not to be confused with the Go programming language). The main reason these feats are possible is the success of deep learning and reinforcement learning (more on the latter given in the next section below). Some of the important algorithms and applications that data scientists have to be aware of in deep learning are:

- Long Short term Memories (LSTMs) for Natural Language Processing
- Recurrent Neural Networks (RNNs) for Speech Recognition
- Convolutional Neural Networks (CNNs) for Image Processing
- Deep Neural Networks (DNNs) for Image Recognition and Classification
- Hybrid Architectures for Recommender Systems
- Autoencoders (ANNs) for Bioinformatics, Wearables, and Healthcare

Deep Learning Networks typically have millions of neurons and hundreds of millions of connections between neurons. Training such networks is such a computationally intensive task that now companies are turning to the 1) Cloud Computing Systems and 2) Graphical Processing Unit (GPU) Parallel High-Performance Processing Systems for their computational needs. It is now common to find hundreds of GPUs operating in parallel to train ridiculously high dimensional neural networks for amazing applications like dreaming during sleep and computer artistry and artistic creativity pleasing to our aesthetic senses.

For more on Deep Learning, please visit the following links:

For information on a full-fledged course in deep learning, visit the following link:

### 8. Reinforcement Learning (RL)

In the recent past and the last three years in particular, reinforcement learning has become remarkably famous for a number of achievements in cognition that were earlier thought to be limited to humans. Basically put, **reinforcement learning **deals with the ability of a computer **to teach itself. **We have the idea of a reward vs. penalty approach. The computer is given a scenario and ‘rewarded’ with points for correct behaviour and ‘penalties’ are imposed for wrong behaviour. The computer is provided with a problem formulated as a **Markov Decision Process**, or **MDP**. Some basic types of Reinforcement Learning algorithms to be aware of are (some extracts from Wikipedia):

**1.Q-Learning**

**Q-Learning** is a model-free reinforcement learning algorithm. The goal of Q-learning is to learn a policy, which tells an agent what action to take under what circumstances. It does not require a model (hence the connotation “model-free”) of the environment, and it can handle problems with stochastic transitions and rewards, without requiring adaptations. For any finite Markov decision process (FMDP), *Q*-learning finds a policy that is optimal in the sense that it maximizes the expected value of the total reward over any and all successive steps, starting from the current state. *Q*-learning can identify an optimal action-selection policy for any given FMDP, given infinite exploration time and a partly-random policy. “Q” names the function that returns the reward used to provide the reinforcement and can be said to stand for the “quality” of an action taken in a given state.

**2.SARSA**

**State–action–reward–state–action** (**SARSA**) is an algorithm for learning a Markov decision process policy. This name simply reflects the fact that the main function for updating the Q-value depends on the current state of the agent “**S**_{1}“, the action the agent chooses “**A**_{1}“, the reward “**R**” the agent gets for choosing this action, the state “**S**_{2}” that the agent enters after taking that action, and finally the next action “**A**_{2}” the agent choose in its new state. The acronym for the quintuple (s_{t}, a_{t}, r_{t}, s_{t+1}, a_{t+1}) is SARSA.

**3.Deep Reinforcement Learning**

This approach extends reinforcement learning by using a deep neural network and without explicitly designing the state space. The work on learning ATARI games by Google DeepMind increased attention to deep reinforcement learning or end-to-end reinforcement learning. Remarkably, the computer agent DeepMind has achieved levels of skill higher than humans at playing computer games. Even a complex game like DOTA 2 was won by a deep reinforcement learning network based upon DeepMind and OpenAI Gym environments that beat human players 3-2 in a tournament of best of five matches.

For more information, go through the following links:

and

Finally:

### 9. AutoML (Bonus)

If reinforcement learning was cutting edge data science, AutoML is bleeding edge data science. **AutoML** (**Auto**mated **M**achine **L**earning) is a remarkable project that is open source and available on GitHub at the following link that, remarkably, uses an algorithm and a data analysis approach to construct an end-to-end data science project that does data-preprocessing, algorithm selection,hyperparameter tuning, cross-validation and algorithm optimization to completely automate the ML process into the hands of a computer. Amazingly, what this means is that now computers can handle the ML expertise that was earlier in the hands of a few limited ML practitioners and AI experts.

**AutoML** has found its way into **Google TensorFlow through AutoKeras, Microsoft CNTK**, and **Google Cloud Platform, Microsoft Azure**, and **Amazon Web Services (AWS). **Currently it is a premiere paid model for even a moderately sized dataset and is free only for tiny datasets. However, one entire process might take one to two or more days to execute completely. But at least, now the computer AI industry has come full circle. We now have computers so complex that they are taking the machine learning process out of the hands of the humans and creating models that are significantly more accurate and faster than the ones created by human beings!

The basic algorithm used by AutoML is Network Architecture Search and its variants, given below:

- Network Architecture Search (NAS)
- PNAS (Progressive NAS)
- ENAS (Efficient NAS)

The functioning of AutoML is given by the following diagram:

For more on AutoML, please visit the link

and

If you’ve stayed with me till now, congratulations; you have learnt a lot of information and cutting edge technology that you must read up on, much, much more. You could start with the links in this article, and of course, Google is your best friend as a Machine Learning Practitioner. **Enjoy** machine learning!

**Follow this link**, if you are looking to **learn data science online****!**

You can **follow this link for our ****Big Data course**, which is a step further into advanced data analysis and processing**!**

Additionally, if you are having an interest in **learning Data Science, click here to start the ****Online Data Science Course**

Furthermore, if you want to read more about data science, read our **Data Science Blogs**