introduction to logistic regression

logistic regression is a supervised learning classification algorithm used to predict the probability of a target variable. the nature of target or dependent variable is dichotomous, which means there would be only two possible classes.

in simple words, the dependent variable is binary in nature having data coded as either 1 (stands for success/yes) or 0 (stands for failure/no).

mathematically, a logistic regression model predicts p(y=1) as a function of x. it is one of the simplest ml algorithms that can be used for various classification problems such as spam detection, diabetes prediction, cancer detection etc.

types of logistic regression

generally, logistic regression means binary logistic regression having binary target variables, but there can be two more categories of target variables that can be predicted by it. based on those number of categories, logistic regression can be divided into following types −

binary or binomial

in such a kind of classification, a dependent variable will have only two possible types either 1 and 0. for example, these variables may represent success or failure, yes or no, win or loss etc.

multinomial

in such a kind of classification, dependent variable can have 3 or more possible unordered types or the types having no quantitative significance. for example, these variables may represent "type a" or "type b" or "type c".

ordinal

in such a kind of classification, dependent variable can have 3 or more possible ordered types or the types having a quantitative significance. for example, these variables may represent "poor" or "good", "very good", "excellent" and each category can have the scores like 0,1,2,3.

logistic regression assumptions

before diving into the implementation of logistic regression, we must be aware of the following assumptions about the same −

in case of binary logistic regression, the target variables must be binary always and the desired outcome is represented by the factor level 1.
there should not be any multi-collinearity in the model, which means the independent variables must be independent of each other .
we must include meaningful variables in our model.
we should choose a large sample size for logistic regression.

binary logistic regression model

the simplest form of logistic regression is binary or binomial logistic regression in which the target or dependent variable can have only 2 possible types either 1 or 0. it allows us to model a relationship between multiple predictor variables and a binary/binomial target variable. in case of logistic regression, the linear function is basically used as an input to another function such as in the following relation −

$$h_{\theta}{(x)}=g(\theta^{t}x) 0h_{\theta}1$$

here, is the logistic or sigmoid function which can be given as follows −

$$g(z)= \frac{1}{1+e^{-z}} =\theta ^{t}$$

to sigmoid curve can be represented with the help of following graph. we can see the values of y-axis lie between 0 and 1 and crosses the axis at 0.5.

the classes can be divided into positive or negative. the output comes under the probability of positive class if it lies between 0 and 1. for our implementation, we are interpreting the output of hypothesis function as positive if it is 0.5, otherwise negative.

we also need to define a loss function to measure how well the algorithm performs using the weights on functions, represented by theta as follows −

$$=()$$

$$j(\theta) = \frac{1}{m}.(-y^{t}log(h) - (1 -y)^tlog(1-h))$$

now, after defining the loss function our prime goal is to minimize the loss function. it can be done with the help of fitting the weights which means by increasing or decreasing the weights. with the help of derivatives of the loss function w.r.t each weight, we would be able to know what parameters should have high weight and what should have smaller weight.

the following gradient descent equation tells us how loss would change if we modified the parameters −

$$\frac{()}{\theta_{j}}=\frac{1}{m}x^{t}(())$$

implementation of binary logistic regression model in python

now we will implement the above concept of binomial logistic regression in python. for this purpose, we are using a multivariate flower dataset named iris which have 3 classes of 50 instances each, but we will be using the first two feature columns. every class represents a type of iris flower.

first, we need to import the necessary libraries as follows −

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import datasets

next, load the iris dataset as follows −

iris = datasets.load_iris()
x = iris.data[:, :2]
y = (iris.target != 0) * 1

we can plot our training data s follows −

plt.figure(figsize=(6, 6))
plt.scatter(x[y == 0][:, 0], x[y == 0][:, 1], color='g', label='0')
plt.scatter(x[y == 1][:, 0], x[y == 1][:, 1], color='y', label='1')
plt.legend();

next, we will define sigmoid function, loss function and gradient descend as follows −

class logisticregression:
   def __init__(self, lr=0.01, num_iter=100000, fit_intercept=true, verbose=false):
      self.lr = lr
      self.num_iter = num_iter
      self.fit_intercept = fit_intercept
      self.verbose = verbose
   def __add_intercept(self, x):
      intercept = np.ones((x.shape[0], 1))
      return np.concatenate((intercept, x), axis=1)
   def __sigmoid(self, z):
      return 1 / (1 + np.exp(-z))
   def __loss(self, h, y):
      return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
   def fit(self, x, y):
      if self.fit_intercept:
         x = self.__add_intercept(x)

now, initialize the weights as follows −

self.theta = np.zeros(x.shape[1])
   for i in range(self.num_iter):
      z = np.dot(x, self.theta)
      h = self.__sigmoid(z)
      gradient = np.dot(x.t, (h - y)) / y.size
      self.theta -= self.lr * gradient
      z = np.dot(x, self.theta)
      h = self.__sigmoid(z)
      loss = self.__loss(h, y)
      if(self.verbose ==true and i % 10000 == 0):
         print(f'loss: {loss} \t')

with the help of the following script, we can predict the output probabilities −

def predict_prob(self, x):
   if self.fit_intercept:
      x = self.__add_intercept(x)
   return self.__sigmoid(np.dot(x, self.theta))
def predict(self, x):
   return self.predict_prob(x).round()

next, we can evaluate the model and plot it as follows −

model = logisticregression(lr=0.1, num_iter=300000)
preds = model.predict(x)
(preds == y).mean()

plt.figure(figsize=(10, 6))
plt.scatter(x[y == 0][:, 0], x[y == 0][:, 1], color='g', label='0')
plt.scatter(x[y == 1][:, 0], x[y == 1][:, 1], color='y', label='1')
plt.legend()
x1_min, x1_max = x[:,0].min(), x[:,0].max(),
x2_min, x2_max = x[:,1].min(), x[:,1].max(),
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))
grid = np.c_[xx1.ravel(), xx2.ravel()]
probs = model.predict_prob(grid).reshape(xx1.shape)
plt.contour(xx1, xx2, probs, [0.5], linewidths=1, colors='red');

multinomial logistic regression model

another useful form of logistic regression is multinomial logistic regression in which the target or dependent variable can have 3 or more possible unordered types i.e. the types having no quantitative significance.

implementation of multinomial logistic regression model in python

now we will implement the above concept of multinomial logistic regression in python. for this purpose, we are using a dataset from sklearn named digit.

first, we need to import the necessary libraries as follows −

import sklearn
from sklearn import datasets
from sklearn import linear_model
from sklearn import metrics
from sklearn.model_selection import train_test_split

next, we need to load digit dataset −

digits = datasets.load_digits()

now, define the feature matrix(x) and response vector(y)as follows −

x = digits.data
y = digits.target

with the help of next line of code, we can split x and y into training and testing sets −

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.4, random_state=1)

now create an object of logistic regression as follows −

digreg = linear_model.logisticregression()

now, we need to train the model by using the training sets as follows −

digreg.fit(x_train, y_train)

next, make the predictions on testing set as follows −

y_pred = digreg.predict(x_test)

next print the accuracy of the model as follows −

print("accuracy of logistic regression model is:",
metrics.accuracy_score(y_test, y_pred)*100)

output

accuracy of logistic regression model is: 95.6884561891516

from the above output we can see the accuracy of our model is around 96 percent.

Save or share this article