- Read
- Top Stories
- Write
- Listen
- Learn
Web Development Data Science - What is it?
- Best 50 Sites to Learn it
- Data Engineering
- Data Science Course 2020 ๐
- Deep Learning A-Z ๐
- Deep Learning vs. Machine Learning
- Love
- ML Essentials
- PG Program in Artificial Intelligence and Machine Learning ๐
- Optimize Your CV
- Python for Machine Learning ๐
- Statistics for Data Science and Business Analysis๐
- Zero to H...

Languages - Advertise
- About
- Tech Companies
- Experts ๐

Introduction to Machine Learning Algorithms: Logistic Regression by@grohith327

May 28th 2018 58,849 reads

Logistic regression is the most famous machine learning algorithm after linear regression. In a lot of ways, linear regression and logistic regression are similar. But, the biggest difference lies in what they are used for. Linear regression algorithms are used to predict/forecast values but logistic regression is used for classification tasks. If you are shaky on the concepts of linear regression, check this out. There are many classification tasks done routinely by people. For example, classifying whether an email is a spam or not, classifying whether a tumour is malignant or benign, classifying whether a website is fraudulent or not, etc. These are typical examples where machine learning algorithms can make our lives a lot easier. A really simple, rudimental and useful algorithm for classification is the logistic regression algorithm. Now, letโs take a deeper look into logistic regression.

Logistic regression algorithm also uses a linear equation with independent predictors to predict a value. The predicted value can be anywhere between negative infinity to positive infinity. We need the output of the algorithm to be class variable, i.e 0-no, 1-yes. Therefore, we are squashing the output of the linear equation into a range of [0,1]. To squash the predicted value between 0 and 1, we use the sigmoid function.

We take the output(z) of the linear equation and give to the function g(x) which returns a squashed value h, the value h will lie in the range of 0 to 1. To understand how sigmoid function squashes the values within the range, letโs visualize the graph of the sigmoid function.

As you can see from the graph, the sigmoid function becomes asymptote to y=1 for positive values of x and becomes asymptote to y=0 for negative values of x.

Since we are trying to predict class values, we cannot use the same cost function used in linear regression algorithm. Therefore, we use a logarithmic loss function to calculate the cost for misclassifying.

The above cost function can be rewritten as below since calculating gradients from the above equation is difficult.

We take partial derivatives of the cost function with respect to each parameter(theta_0, theta_1,ย โฆ) to obtain the gradients. with the help of these gradients, we can update the values of theta_0, theta_1,ย โฆ To understand the equations below you would need some calculus.

But, if you are not able to understand them you can ask me or you can just take them as they are.

Now that we have formulated the equations necessary, letโs write the code. We will be using only the numpy library to build the model from scratch. I believe this would provide an understanding of what is happening under the hood. We will be using the Iris dataset to train and test the algorithm.

We load the data using pandas library. The Iris dataset has three target values(โIris-virginicaโ, โIris-setosaโ, โIris-versicolorโ). Since we would like to implement a binary classification algorithm, I decided to drop the rows with target value Iris-virginica. Now, we have only two target classes to predict. We extract the independent and dependent variables from the dataset. Now, letโs move on to preparing the training and testing data.

We shuffle the data and split it into training and testing data. There are 90 examples in our training data and 10 examples in our test data. There are four predictors in the dataset. Therefore, we extract each of the features and store it in individual vectors.

We initialize the parameters(theta_0, theta_1,ย โฆ) with 0. During each epoch, we calculate the values using the linear equation, squash the values within the range of 0 to 1 and then we calculate the cost. From the cost function, we calculate the gradients for each parameter and update their values by multiplying gradients with alpha. Alpha is the learning rate of the algorithm. After 10000 epochs, our algorithm wouldโve converged to the minima. We can test our algorithm with the test data.

We prepare the test data features similar to the training data. We also clip the values of theta_0, theta_1, theta_2, theta_3 and theta_4 from 90x1 to 10x1 as the number of testing examples is only 10. We calculate the test classes and check the accuracy of our model.

Our model is able to achieve 100% accuracy. Even though logistic regression is a pretty powerful algorithm, the dataset we have used isnโt really complex. Therefore, our model is able to achieve 100% accuracy. We can also visualize the cost function value as our model trained for 10000 epochs.

Now, you might be wondering that this is a lot of lines of code to implement a simple algorithm. To save us from typing so many lines of code, we can use the scikit learn library. The scikit learn library has a built-in class for logistic regression which we can just import and use.

Over 50 lines of code have been reduced to under 10 lines of code. We also get 100% accuracy though scikit learn libraryโs logistic regression class.

Logistic regression is a simple algorithm that can be used for binary/multivariate classification tasks. I think by now you wouldโve obtained a basic understanding of how logistic regression algorithm works. Hope this article was helpfulย :)

Join Hacker Noon

Create your free account to unlock your custom reading experience.