Machine Learning – 18 – Simple LinearRegression

Simple linear regression -க்கான சமன்பாடு பின்வருமாறு அமையும். இதை வைத்து (1,1) , (2,2) , (3,3) எனும் புள்ளி விவரங்களுக்கு பின்வரும் கணிப்பான் h(x) மூலம் கணிப்பதை நாம் இங்கு உதாரணமாக எடுத்துக் கொள்வோம்.

இந்தக் கணிப்பானது தீட்டா-0 மற்றும் தீட்டா-1 எனும் இரண்டு முக்கிய parameters-ஐப் பொறுத்தே அமைகிறது. எனவே வெவ்வேறு மதிப்புள்ள parameters-க்கு வெவ்வேறு வகையில் கணிப்புகள் நிகழ்த்தப்படுவதை பின்வரும் உதாரணத்தில் காணலாம்.


import matplotlib.pyplot as plt
x = [1, 2, 3]
y = [1, 2, 3]
plt.figure()
plt.title('Data – X and Y')
plt.plot(x,y,'*')
plt.xticks([0,1,2,3])
plt.yticks([0,1,2,3])
plt.show()
def linear_regression(theta0,theta1):
predicted_y = []
for i in x:
predicted_y.append((theta0+(theta1*i)))
plt.figure()
plt.title('Predictions')
plt.plot(x,predicted_y,'.')
plt.xticks([0,1,2,3])
plt.yticks([0,1,2,3])
plt.show()
theta0 = 1.5
theta1 = 0
linear_regression(theta0,theta1)
theta0a = 0
theta1a = 1.5
linear_regression(theta0a,theta1a)
theta0b = 1
theta1b = 0.5
linear_regression(theta0b,theta1b)

முதலில் (1,1) , (2,2) , (3,3) –க்கான வரைபடம் வரையப்படுகிறது. பின்னர் தீட்டா-0 =1.5, தீட்டா-1 =0 எனும் போது பின்வரும் சமன்பாட்டில் பொருத்தி (1, 1.5) , (2, 1.5) , (3, 1.5) எனும் மதிப்புகளையும்,

h(1) = 1.5 + 0(1) = 1.5

h(2) = 1.5 + 0(2) = 1.5

h(3) = 1.5 + 0(3) = 1.5

அவ்வாறே தீட்டா-0 =0, தீட்டா-1 =1.5 எனும் போது (1, 1.5) , (2, 3) , (3, 4.5) எனும் மதிப்புகளையும், கடைசியாக தீட்டா-0 =1, தீட்டா-1 =0.5 எனும் போது (1, 1.5) , (2, 2) , (3, 2.5) எனும் மதிப்புகளையும் அளிப்பதைக் காணலாம்.

h(1) = 0 + 1.5(1) = 1.5 h(1) = 1 + 0.5(1) = 1.5

h(2) = 0 + 1.5(2) = 3 h(2) = 1 + 0.5(2) = 2

h(3) = 0 + 1.5(3) = 4.5 h(3) = 1 + 0.5(3) = 2.5

இவ்வாறு கண்டுபிடிக்கப்பட்ட மதிப்புகளுக்கு வரைபடங்கள் வரையப்படுகின்றன. இவை பின்வருமாறு அமையும்.

மேற்கண்ட 3 கணிப்புகளில் எதன் கணிப்பு உண்மையான மதிப்புகளுக்கு அருகில் உள்ளதோ அதனுடைய தீட்டா மதிப்புகளையே நாம் இறுதியாக கணிப்பிற்கு எடுத்துக்கொள்ளலாம். இங்கு (1,1) , (2,2) , (3,3) எனும் மதிப்புகளுக்கு (1, 1.5) , (2, 2) , (3, 2.5) எனும் மதிப்புகள் சற்று அருகில் வந்துள்ளது. எனவே தீட்டா-0 =1, தீட்டா-1 =0.5 எனும் மதிப்புகளைக் கொண்ட கணிப்பானையே நாம் தேர்வு செய்து கொள்வோம்.

இங்கு வெறும் 3 தரவுகள் மட்டும் இருப்பதால், எதை வைத்துக் கணித்தால் கணிப்பிற்கும் உண்மையான மதிப்பிற்குமான வேறுபாடு சற்று குறைவாக இருக்கும் என நம்மால் சுலபமாகக் கூற முடியும். ஆனால் நிஜத்தில் ஆயிரக்கணக்கில் தரவுகள் இருக்கும்போது, இந்த வேறுபாட்டினைக் கண்டறிந்து கூற உதவும் சூத்திரமே cost function ஆகும்.

Cost Function:

இதற்கான சமன்பாடு பின்வருமாறு.

J = cost function

m = மொத்த தரவுகளின் எண்ணிக்கை

i = மொத்தத் தரவுகளில் ஒவ்வொன்றாகச் செல்ல உதவும். .

h(x) = கணிக்கப்படுகின்ற மதிப்பு

y = எதிர்பார்க்கின்ற உண்மையான மதிப்பு

மேற்கண்ட அதே புள்ளி விவரங்களை பின்வரும் சமன்பாட்டில் பொருத்தி, நாம் தேர்ந்தெடுத்துதுள்ள கணிப்பான் சிறிய அளவு cost வேறுபாட்டினை வெளிப்படுத்துகிறதா எனக் காணவும். இதற்கான நிரல் பின்வருமாறு.


import matplotlib.pyplot as plt
x = [1, 2, 3]
y = [1, 2, 3]
m = len(y)
def cost_function(theta0,theta1):
predicted_y = [theta0+(theta1*1), theta0+(theta1*2), theta0+(theta1*3)]
sum=0
for i,j in zip(predicted_y,y):
sum = sum+((i-j)**2)
J = 1/(2*m)*sum
return (J)
theta0 = [1.5,0,1]
theta1 = [0,1.5,0.5]
for i,j in zip(theta0,theta1):
print ("cost when theta0=%r theta1=%r :"%(i,j), cost_function(i,j))

வெளியீடு:

cost when theta0=1.5 theta1=0 : 0.4583333333333333
cost when theta0=0 theta1=1.5 : 0.5833333333333333
cost when theta0=1 theta1=0.5 : 0.08333333333333333

கணக்கீடு நிகழும் விதம்:

(1, 1.5) , (2, 1.5) , (3, 1.5) vs (1, 1) , (2, 2) , (3, 3) (தீட்டா-0 =1.5, தீட்டா-1 =0)

J = 1/2*3 [(1.5-1)**2 + (1.5-2)**2 + (1.5-3)**2] = 1/6 [0.25 + 0.25 + 2.25] = 2.75

(1, 1.5) , (2, 3) , (3, 4.5) vs (1, 1) , (2, 2) , (3, 3) (தீட்டா-0 =0, தீட்டா-1 =1.5)

J = 1/2*3 [(1.5-1)**2 + (3-2)**2 + (4.5-3)**2] = 1/6 [0.25 + 1 + 2.25] = 3.50

(1, 1.5) , (2, 2) , (3, 2.5) vs (1, 1) , (2, 2) , (3, 3) (தீட்டா-0 =1, தீட்டா-1 =0.5)

J = 1/2*3 [(1.5-1)**2 + (2-2)**2 + (2.5-3)**2] = 1/6 [0.25 + 0 + 0.25] = 0.50

இதில் தனித்தனி வேறுபாடுகளைக் கூட்டி அதன் சராசரியைக் கண்டுபிடிப்பதன் மூலம் ஒவ்வொரு கணிப்பான் நடத்தும் கணிப்பும் எந்த அளவு வேறுபாடில் அமையும் என்பதைக் கூற முடியும்.இத்தகைய வேறுபாடுகளின் மடங்குகள் கண்டுபிடிக்கப்பட்டு அவை 2-ஆல் வகுக்கப்படுவதற்கான காரணம் என்னவெனில், சராசரியைக் கண்டுபிடிக்கும்போது ஏதாவது ஒரு எதிர்மறை எண் இருந்தால்கூட அது கூட்டப்படுவதற்கு பதிலாக கழிக்கப்பட்டு விடும். எனவேதான் சூத்திரம் இதுபோன்று அமைக்கப்பட்டுள்ளது. இதுவே sum of squares error என்று அழைக்கப்படும்.

இங்கு நாம் ஏற்கனவே கண்டுபிடித்த தீட்டா-0 =1, தீட்டா-1 =0.5 மதிப்புகள் கொண்ட கணிப்பானே குறைந்த அளவு cost-ஐ வெளிப்படுத்துவதைக் காணலாம்(0.50). எனவே தரவுகளின் எண்ணிக்கை பெருகினாலும், இந்த சூத்திரத்தின் மூலம் வேறுபாட்டினை நாம் சுலபமாகக் கணக்கிடாலாம்.

இந்த 0.50 எனும் வேறுபாடு சற்று அதிகம் எனக் கருதினால், இதனை நாம் இன்னும் குறைக்க பல்வேறு தீட்டாக்களுக்கு இச்சோதனையை திரும்பத் திரும்ப செய்து அதில் குறைவான வேறுபாடு ஏற்படுத்தும் தீட்டாக்களை கண்டுபிடிக்க உதவுவதே Gradient descent ஆகும். அதற்கு முதலில் பல்வேறு தீட்டாக்களின் மதிப்பையும், அவற்றுக்கான cost-ஐயும் ஒரு வரைபடமாக வரைந்து பார்ப்போம். இதுவே contour plots ஆகும்.

Contour plots:

தீட்டா-0 , தீட்டா-1 மற்றும் இவ்விரண்டின் அடிப்படையில் கண்டறியப்பட்ட cost மதிப்பு இம்மூன்றையும் முப்பரிமாண வரைபடமாக வரைந்து காட்ட உதவுவதே contour வரைபடம் ஆகும். இது கிண்ண வடிவிலோ அல்லது வட்ட வடிவிலோ பின்வருமாறு இருக்கும். புள்ளி வைத்துள்ள இடங்களில் எல்லாம் cost இருக்கிறது என வைத்துக் கொண்டால், அவற்றை எல்லாம் இணைப்பதன் மூலம் கிண்ணம் போன்ற ஒரு வடிவம் ஏற்படும்.

வட்டம் போன்ற வரைபடத்தில் பல்வேறு தீட்டா மதிப்புகளுக்கான cost பல்வேறு வட்டங்களாக வெளிப்படுகின்றன. எனவே வட்டத்தின் மையத்தைக் கண்டறிவதன் மூலமோ அல்லது கிண்ணத்தின் அடிப்பாகத்தை அடைவதன் மூலமோ குறைந்த அளவு வேறுபாட்டினை வெளிப்படுத்தக் கூடிய தீட்டாக்களை நாம் கண்டறிய முடியும். இந்த வேலையையே Gradient descent செய்கிறது.

கீழ்க்கண்ட நிரலில் -2 லிருந்து 2 வரை தீட்டாக்களுக்கு 100 முறை மதிப்புகள் மாற்றி மாற்றி அளிக்கப்பட்டு cost கண்டறியப்படுகிறது. இங்கு numpy மூலம் தீட்டாக்களுக்கு மதிப்புகள் வழங்கப்படுகின்றன. இவை uniform distribution முறையில் அமையும்.


from mpl_toolkits.mplot3d.axes3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
fig, ax1 = plt.subplots(figsize=(8, 5),
subplot_kw={'projection': '3d'})
values = 2
r = np.linspace(-values,values,100)
theta0,theta1= np.meshgrid(r,r)
original_y = [1, 2, 3]
m = len(original_y)
predicted_y = [theta0+(theta1*1), theta0+(theta1*2), theta0+(theta1*3)]
sum=0
for i,j in zip(predicted_y,original_y):
sum = sum+((i-j)**2)
J = 1/(2*m)*sum
ax1.plot_wireframe(theta0,theta1,J)
ax1.set_title("plot")
plt.show()

நமது தரவுகளுக்கான வரைபடம் பின்வருமாறு.

%d bloggers like this: