FilesExpand file tree

 patch-1

/

logistic_regression.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

101 lines (70 loc) · 2.45 KB

 patch-1

/

logistic_regression.py

Copy path

Top

File metadata and controls

• Code
• Blame

101 lines (70 loc) · 2.45 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

#!/usr/bin/python

# -*- coding: utf-8 -*-

## Logistic Regression from scratch

# In[62]:

# In[63]:

# importing all the required libraries

''' Implementing logistic regression for classification problem

Helpful resources : 1.Coursera ML course 2.https://medium.com/@martinpella/logistic-regression-from-scratch-in-python-124c5636b8ac'''

import numpy as np

import matplotlib.pyplot as plt

# get_ipython().run_line_magic('matplotlib', 'inline')

from sklearn import datasets

# In[67]:

# sigmoid function or logistic function is used as a hypothesis function in classification problems

def sigmoid_function(z):

return 1 / (1 + np.exp(-z))

def cost_function(h, y):

return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()

# here alpha is the learning rate, X is the feature matrix,y is the target matrix

def logistic_reg(

alpha,

X,

y,

max_iterations=70000,

):

converged = False

iterations = 0

theta = np.zeros(X.shape[1])

while not converged:

z = np.dot(X, theta)

h = sigmoid_function(z)

gradient = np.dot(X.T, h - y) / y.size

theta = theta - alpha * gradient

z = np.dot(X, theta)

h = sigmoid_function(z)

J = cost_function(h, y)

iterations += 1 # update iterations

if iterations == max_iterations:

print ('Maximum iterations exceeded!')

print ('Minimal cost function J=', J)

converged = True

return theta

# In[68]:

if __name__ == '__main__':

iris = datasets.load_iris()

X = iris.data[:, :2]

y = (iris.target != 0) * 1

alpha = 0.1

theta = logistic_reg(alpha, X, y, max_iterations=70000)

print (theta)

def predict_prob(X):

return sigmoid_function(np.dot(X, theta)) # predicting the value of probability from the logistic regression algorithm

plt.figure(figsize=(10, 6))

plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='b', label='0')

plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='r', label='1')

(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 = predict_prob(grid).reshape(xx1.shape)

plt.contour(

xx1,

xx2,

probs,

[0.5],

linewidths=1,

colors='black',

)

plt.legend()