# AI News, Ten Machine Learning Algorithms You Should Know to Become a Data Scientist

- On Friday, August 3, 2018
- By Read More

## Ten Machine Learning Algorithms You Should Know to Become a Data Scientist

That said, no one can deny the fact that as practicing Data Scientists, we will have to know basics of some common machine learning algorithms, which would help us engage with a new-domain problem we come across.

Covariance Matrix of data points is analyzed here to understand what dimensions(mostly)/ data points (sometimes) are more important (ie have high variance amongst themselves, but low covariance with others).

As is obvious, use this algorithm to fit simple curves / regression https://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.lstsq.html https://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.polyfit.html https://lagunita.stanford.edu/c4x/HumanitiesScience/StatLearning/asset/linear_regression.pdf Least Squares can get confused with outliers, spurious fields and noise in data.

As is obvious from the name, you can use this algorithm to create K clusters in dataset http://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html https://www.youtube.com/watch?v=hDmNF9JG3lo https://www.datascience.com/blog/k-means-clustering Logistic Regression is constrained Linear Regression with a nonlinearity (sigmoid function is used mostly or you can use tanh too) application after weights are applied, hence restricting the outputs close to +/- classes (which is 1 and 0 in case of sigmoid).

http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html https://www.youtube.com/watch?v=-la3q9d7AKQ SVMs are linear models like Linear/ Logistic Regression, the difference is that they have different margin-based loss function (The derivation of Support Vectors is one of the most beautiful mathematical results I have seen along with eigenvalue calculation).

FFNNs can be used to train a classifier or extract features as autoencoders http://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html#sklearn.neural_network.MLPClassifier http://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPRegressor.html https://github.com/keras-team/keras/blob/master/examples/reuters_mlp_relu_vs_selu.py http://www.deeplearningbook.org/contents/mlp.html http://www.deeplearningbook.org/contents/autoencoders.html http://www.deeplearningbook.org/contents/representation.html Almost any state of the art Vision based Machine Learning result in the world today has been achieved using Convolutional Neural Networks.

https://developer.nvidia.com/digits https://github.com/kuangliu/torchcv https://github.com/chainer/chainercv https://keras.io/applications/ http://cs231n.github.io/ https://adeshpande3.github.io/A-Beginner%27s-Guide-To-Understanding-Convolutional-Neural-Networks/ RNNs model sequences by applying the same set of weights recursively on the aggregator state at a time t and input at a time t (Given a sequence has inputs at times 0..t..T, and have a hidden state at each time t which is output from t-1 step of RNN).

RNN (If here is a densely connected unit and a nonlinearity, nowadays f is generally LSTMs or GRUs ). LSTM unit which is used instead of a plain dense layer in a pure RNN.

Use RNNs for any sequence modelling task specially text classification, machine translation, language modelling https://github.com/tensorflow/models (Many cool NLP research papers from Google are here) https://github.com/wabyking/TextClassificationBenchmark http://opennmt.net/ http://cs224d.stanford.edu/ http://www.wildml.com/category/neural-networks/recurrent-neural-networks/ http://colah.github.io/posts/2015-08-Understanding-LSTMs/ CRFs are probably the most frequently used models from the family of Probabilitic Graphical Models (PGMs).

Before Neural Machine Translation systems came in CRFs were the state of the art and in many sequence tagging tasks with small datasets, they will still learn better than RNNs which require a larger amount of data to generalize.

The two common decision trees algorithms used nowadays are Random Forests (which build different classifiers on a random subset of attributes and combine them for output) and Boosting Trees (which train a cascade of trees one on top of others, correcting the mistakes of ones below them).

Decision Trees can be used to classify datapoints (and even regression) http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingClassifier.html http://xgboost.readthedocs.io/en/latest/ https://catboost.yandex/ http://xgboost.readthedocs.io/en/latest/model.html https://arxiv.org/abs/1511.05741 https://arxiv.org/abs/1407.7502 http://education.parrotprediction.teachable.com/p/practical-xgboost-in-python If you are still wondering how can any of the above methods solve tasks like defeating Go world champion like DeepMind did, they cannot.

To learn strategy to solve a multi-step problem like winning a game of chess or playing Atari console, we need to let an agent-free in the world and learn from the rewards/penalties it faces.

- On Friday, August 3, 2018
- By Read More

## Selecting the best Machine Learning algorithm for your regression problem

Beginning with the simple case, Single Variable Linear Regression is a technique used to model the relationship between a single input independent variable (feature variable) and an output dependent variable using a linear model i.e a line.

The more general case is Multi Variable Linear Regression where a model is created for the relationship between multiple independent input variables (feature variables) and an output dependent variable.

The input feature variables from the data are passed to these neurons as a multi-variable linear combination, where the values multiplied by each feature variable are known as weights.

Tree induction is the task of taking a set of training instances as input, deciding which attributes are best to split on, splitting the dataset, and recurring on the resulting split datasets until all training instances are categorized.

While building the tree, the goal is to split on the attributes which create the purest child nodes possible, which would keep to a minimum the number of splits that would need to be made in order to classify all instances in our dataset.

In practice, this is measured by comparing entropy, or the amount of information needed to classify a single instance of a current dataset partition, to the amount of information to classify a single instance if the current dataset partition were to be further partitioned on a given attribute.

- On Friday, August 3, 2018
- By Read More

## Essentials of Machine Learning Algorithms (with Python and R Codes)

Note: This article was originally published on Aug 10, 2015 and updated on Sept 9th, 2017

Google’s self-driving cars and robots get a lot of press, but the company’s real future is in machine learning, the technology that enables computers to get smarter and more personal.

The idea behind creating this guide is to simplify the journey of aspiring data scientists and machine learning enthusiasts across the world.

How it works: This algorithm consist of a target / outcome variable (or dependent variable) which is to be predicted from a given set of predictors (independent variables).

Using these set of variables, we generate a function that map inputs to desired outputs. The training process continues until the model achieves a desired level of accuracy on the training data.

This machine learns from past experience and tries to capture the best possible knowledge to make accurate business decisions.

These algorithms can be applied to almost any data problem: It is used to estimate real values (cost of houses, number of calls, total sales etc.) based on continuous variable(s).

In this equation: These coefficients a and b are derived based on minimizing the sum of squared difference of distance between data points and regression line.

And, Multiple Linear Regression(as the name suggests) is characterized by multiple (more than 1) independent variables. While finding best fit line, you can fit a polynomial or curvilinear regression.

It is a classification not a regression algorithm. It is used to estimate discrete values ( Binary values like 0/1, yes/no, true/false ) based on given set of independent variable(s).

It chooses parameters that maximize the likelihood of observing the sample values rather than that minimize the sum of squared errors (like in ordinary regression).

source: statsexchange In the image above, you can see that population is classified into four different groups based on multiple attributes to identify ‘if they will play or not’.

In this algorithm, we plot each data item as a point in n-dimensional space (where n is number of features you have) with the value of each feature being the value of a particular coordinate.

For example, if we only had two features like Height and Hair length of an individual, we’d first plot these two variables in two dimensional space where each point has two co-ordinates (these co-ordinates are known as Support Vectors)

In the example shown above, the line which splits the data into two differently classified groups is the black line, since the two closest points are the farthest apart from the line.

It is a classification technique based on Bayes’ theorem with an assumption of independence between predictors. In simple terms, a Naive Bayes classifier assumes that the presence of a particular feature in a class is unrelated to the presence of any other feature.

Step 1: Convert the data set to frequency table Step 2: Create Likelihood table by finding the probabilities like Overcast probability = 0.29 and probability of playing is 0.64.

Yes) * P(Yes) / P (Sunny) Here we have P (Sunny |Yes) = 3/9 = 0.33, P(Sunny) = 5/14 = 0.36, P( Yes)= 9/14 = 0.64 Now, P (Yes |

However, it is more widely used in classification problems in the industry. K nearest neighbors is a simple algorithm that stores all available cases and classifies new cases by a majority vote of its k neighbors.

Its procedure follows a simple and easy way to classify a given data set through a certain number of clusters (assume k clusters).

We know that as the number of cluster increases, this value keeps on decreasing but if you plot the result you may see that the sum of squared distance decreases sharply up to some value of k, and then much more slowly after that.

grown as follows: For more details on this algorithm, comparing with decision tree and tuning model parameters, I would suggest you to read these articles: Python R Code

For example: E-commerce companies are capturing more details about customer like their demographics, web crawling history, what they like or dislike, purchase history, feedback and many others to give them personalized attention more than your nearest grocery shopkeeper.

How’d you identify highly significant variable(s) out 1000 or 2000? In such cases, dimensionality reduction algorithm helps us along with various other algorithms like Decision Tree, Random Forest, PCA, Factor Analysis, Identify based on correlation matrix, missing value ratio and others.

GBM is a boosting algorithm used when we deal with plenty of data to make a prediction with high prediction power. Boosting is actually an ensemble of learning algorithms which combines the prediction of several base estimators in order to improve robustness over a single estimator.

The XGBoost has an immensely high predictive power which makes it the best choice for accuracy in events as it possesses both linear model and the tree learning algorithm, making the algorithm almost 10x faster than existing gradient booster techniques.

It is designed to be distributed and efficient with the following advantages: The framework is a fast and high-performance gradient boosting one based on decision tree algorithms, used for ranking, classification and many other machine learning tasks.

Since the LightGBM is based on decision tree algorithms, it splits the tree leaf wise with the best fit whereas other boosting algorithms split the tree depth wise or level wise rather than leaf-wise.

So when growing on the same leaf in Light GBM, the leaf-wise algorithm can reduce more loss than the level-wise algorithm and hence results in much better accuracy which can rarely be achieved by any of the existing boosting algorithms.

Catboost can automatically deal with categorical variables without showing the type conversion error, which helps you to focus on tuning your model better rather than sorting out trivial errors.

My sole intention behind writing this article and providing the codes in R and Python is to get you started right away. If you are keen to master machine learning, start right away.

- On Friday, August 3, 2018
- By Read More

## The Logistic Regression Algorithm

Like many other machine learning techniques, it is borrowed from the field of statistics and despite its name, it is not an algorithm for regression problems, where you want to predict a continuous outcome.

simple example of a Logistic Regression problem would be an algorithm used for cancer detection that takes screening picture as an input and should tell if a patient has cancer (1) or not (0).

Logistic Regression measures the relationship between the dependent variable (our label, what we want to predict) and the one or more independent variables (our features), by estimating probabilities using it’s underlying logistic function.

The Sigmoid-Function is an S-shaped curve that can take any real-valued number and map it into a value between the range of 0 and 1, but never exactly at those limits.

Below you can see how the logistic function (sigmoid function) looks like: We want to maximize the likelihood that a random data point gets classified correctly, which is called Maximum Likelihood Estimation.

It is a widely used technique because it is very efficient, does not require too many computational resources, it’s highly interpretable, it doesn’t require input features to be scaled, it doesn’t require any tuning, it’s easy to regularize, and it outputs well-calibrated predicted probabilities.

Like linear regression, logistic regression does work better when you remove attributes that are unrelated to the output variable as well as attributes that are very similar (correlated) to each other.

Therefore it is required that your data is linearly separable, like the data points in the image below: In other words: You should think about using logistic regression when your Y variable takes on only two values (e.g when you are facing a classification problem).

When you then want to classify an image, you just look at which classifier has the best decision score Here you train a binary classifier for every pair of digits.

This means training a classifier that can distinguish between 0s and 1s, one that can distinguish between 0s and 2s, one that can distinguish between 1s and 2s etc.

Algorithms like Support Vector Machine Classifiers don’t scale well at large datasets, which is why in this case using a binary classification algorithm like Logistic Regression with the OvO strategy would do better, because it is faster to train a lot of classifiers on a small dataset than training just one at a large dataset.

- On Friday, August 3, 2018
- By Read More

## How to choose algorithms for Microsoft Azure Machine Learning

The answer to the question "What machine learning algorithm should I use?"

It depends on how the math of the algorithm was translated into instructions for the computer you are using.

Even the most experienced data scientists can't tell which algorithm will perform best before trying them.

The Microsoft Azure Machine Learning Algorithm Cheat Sheet helps you choose the right machine learning algorithm for your predictive analytics solutions from the Microsoft Azure Machine Learning library of algorithms. This

This cheat sheet has a very specific audience in mind: a beginning data scientist with undergraduate-level machine learning, trying to choose an algorithm to start with in Azure Machine Learning Studio.

That means that it makes some generalizations and oversimplifications, but it points you in a safe direction.

As Azure Machine Learning grows to encompass a more complete set of available methods, we'll add them.

These recommendations are compiled feedback and tips from many data scientists and machine learning experts.

We didn't agree on everything, but I've tried to harmonize our opinions into a rough consensus.

data scientists I talked with said that the only sure way to find

Supervised learning algorithms make predictions based on a set of examples.

For instance, historical stock prices can be used to hazard guesses

company's financial data, the type of industry, the presence of disruptive

it uses that pattern to make predictions for unlabeled testing data—tomorrow's

Supervised learning is a popular and useful type of machine learning.

In unsupervised learning, data points have no labels associated with them.

grouping it into clusters or finding different ways of looking at complex

In reinforcement learning, the algorithm gets to choose an action in response

signal a short time later, indicating how good the decision was. Based

where the set of sensor readings at one point in time is a data

The number of minutes or hours necessary to train a model varies a great deal

time is limited it can drive the choice of algorithm, especially when

regression algorithms assume that data trends follow a straight line.

These assumptions aren't bad for some problems, but on others they bring

Non-linear class boundary - relying on a linear classification algorithm

Data with a nonlinear trend - using a linear regression method would generate

much larger errors than necessary Despite their dangers, linear algorithms are very popular as a first line

Parameters are the knobs a data scientist gets to turn when setting up an

as error tolerance or number of iterations, or options between variants

to make sure you've spanned the parameter space, the time required to

train a model increases exponentially with the number of parameters.

For certain types of data, the number of features can be very large compared

algorithms, making training time unfeasibly long.

Some learning algorithms make particular assumptions about the structure of

- shows excellent accuracy, fast training times, and the use of linearity ○

- shows good accuracy and moderate training times As mentioned previously, linear regression fits

curve instead of a straight line makes it a natural fit for dividing

logistic regression to two-class data with just one feature - the class

boundary is the point at which the logistic curve is just as close to both classes Decision forests (regression, two-class, and multiclass), decision

all based on decision trees, a foundational machine learning concept.

decision tree subdivides a feature space into regions of roughly uniform

values Because a feature space can be subdivided into arbitrarily small regions,

it's easy to imagine dividing it finely enough to have one data point

a large set of trees are constructed with special mathematical care

memory at the expense of a slightly longer training time.

Boosted decision trees avoid overfitting by limiting how many times they can

a variation of decision trees for the special case where you want to know

that input features are passed forward (never backward) through a sequence

a long time to train, particularly for large data sets with lots of features.

typical support vector machine class boundary maximizes the margin separating

Any new data points that fall far outside that boundary

PCA-based anomaly detection - the vast majority of the data falls into

data set is grouped into five clusters using K-means There is also an ensemble one-v-all multiclass classifier, which

- On Friday, August 3, 2018
- By Read More

## Regression vs. Classification Algorithms

We’ve done this before through the lens of whether the data used to train the algorithm should be labeled or not (see our posts onsupervised, unsupervised, or semi-supervised machine learning),but there are also inherent differences in these algorithms based on the format of their outputs.

If these are the questions you’re hoping to answer with machine learning in your business, consider algorithms like naive Bayes, decision trees, logistic regression, kernel approximation, and K-nearest neighbors.

Regression problems with time-ordered inputs are called time-series forecasting problems, like ARIMA forecasting, which allows data scientists to explain seasonal patterns in sales, evaluate the impact of new marketing campaigns, and more.

Though it’s often underrated because of its relative simplicity, it’s a versatile method that can be used to predict housing prices, likelihood of customers to churn, or the revenue a customer will generate.

- On Tuesday, March 19, 2019

**Linear Regression - Machine Learning Fun and Easy**

Linear Regression - Machine Learning Fun and Easy

**Linear Regression Analysis | Linear Regression in Python | Machine Learning Algorithms | Simplilearn**

This Linear Regression in Machine Learning video will help you understand the basics of Linear Regression algorithm - what is Linear Regression, why is it ...

**Regression How it Works - Practical Machine Learning Tutorial with Python p.7**

Welcome to the seventh part of our machine learning regression tutorial within our Machine Learning with Python tutorial series. Up to this point, you have been ...

**Difference between Classification and Regression - Georgia Tech - Machine Learning**

Watch on Udacity: Check out the full Advanced Operating Systems course for free ..

**Linear Regression Algorithm | Linear Regression in Python | Machine Learning Algorithm | Edureka**

Machine Learning Training with Python: ** This Linear Regression Algorithm video is designed in a way that you learn about the ..

**Linear Regression Algorithm | Linear Regression in R | Data Science Training | Edureka**

Data Science Training - ) This Edureka Linear Regression tutorial will help you understand all the basics of linear ..

**Logistic Regression in R | Machine Learning Algorithms | Data Science Training | Edureka**

Data Science Training - ) This Logistic Regression Tutorial shall give you a clear understanding as to how a Logistic ..

**3.4: Linear Regression with Gradient Descent - Intelligence and Learning**

In this video I continue my Machine Learning series and attempt to explain Linear Regression with Gradient Descent. My Video explaining the Mathematics of ...

**Classification or Regression – Machine Learning Interview Preparation Questions**

Looking to nail your Machine Learning job interview? In this video, I explain when classification should be used over regression, which is a commonly asked ...

**Logistic Regression - Fun and Easy Machine Learning**

Logistic Regression - Fun and Easy Machine Learning