Multiple LinearRegression
ஒன்றுக்கும் மேற்பட்ட அம்சங்கள் ஒன்றாகச் சேர்ந்து ஒரு விஷயத்தைக் கணிக்கிறது எனில் அதுவே multiple linear regression எனப்படும். ஒவ்வொரு அம்சமும் x1,x2,x3.. எனக் கொண்டால், இதற்கான சமன்பாடு பின்வருமாறு அமையும்.
multiple linear-ல் ஒவ்வொரு feature-க்கும் ஒரு தீட்டா மதிப்பு காணப்படுமே தவிர, no.of rows –ஐப் பொறுத்து மாறாது. எனவே தீட்டா என்பது எப்போதும் 1 row-ல் பல்வேறு மதிப்புகள் அமைந்துள்ள அணியாக இருக்கும். பின்னர் இந்த அணியை transpose செய்து 1 column-ல் பல்வேறு மதிப்புகள் அமைந்துள்ள வெக்டராக மாற்றலாம். எனவே தான் transpose செய்யப்பட்ட தீட்டா அணியையும், features-க்கான X அணியையும் பெருக்கினால் multiple linear-க்கான சமன்பாடு வந்துவிடுகிறது.
இந்த சமன்பாட்டில் தீட்டா0 –வுடன் x0 எனும் புதிய feature ஒன்று சேர்க்கப்படுகிறது. இது எப்போதும் 1 எனும் மதிப்பையே பெற்றிருக்கும். இந்த புதிய feature-ஆல் தீட்டா0 மதிப்பில் எந்த ஒரு மாற்றமும் ஏற்படாது. வெறும் அணிகளின் பெருக்கலுக்கு துணைபுரியும் வகையில் இது சேர்க்கப்பட்டுள்ளது.
கீழ்க்கண்ட உதாரணத்தில்,
800 சதுர அடி, 2 அறைகள், 15 வருட பழைய வீட்டின் விலை = 3000000
1200 சதுர அடி, 3 அறைகள், 1 வருட பழைய வீட்டின் விலை = 2000000
2400 சதுர அடி, 5 அறைகள், 5 வருட பழைய வீட்டின் விலை = 3500000
எனும் 3 தரவுகள் X எனும் அணியில் கொடுக்கப்பட்டுள்ளன. அவ்வாறே 100, 1000, 10000, 100000 ஆகிய மதிப்புகள் தீட்டா0 , தீட்டா1, தீட்டா2, தீட்டா3 –ன் மதிப்புகளாக தீட்டா எனும் அணியில் கொடுக்கப்பட்டுள்ளன. இவை இரண்டும் மேற்கண்ட சமன்பாட்டின் படி பொருத்தப்பட்டு, h(x) அணியை உருவாக்குகின்றன.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import matplotlib.pyplot as plt | |
| import numpy as np | |
| x = np.array([[1, 800, 2, 15],[1, 1200, 3, 1],[1, 2400, 5, 5]]) | |
| y = np.array([3000000,2000000,3500000]) | |
| theta = np.array([100, 1000, 10000, 100000]) | |
| predicted_y = x.dot(theta.transpose()) | |
| print (predicted_y) | |
| m = y.size | |
| diff = predicted_y – y | |
| squares = np.square(diff) | |
| #sum_of_squares = 5424168464 | |
| sum_of_squares = np.sum(squares) | |
| cost_fn = 1/(2*m)*sum_of_squares | |
| print (diff) | |
| print (squares) | |
| print (sum_of_squares) | |
| print (cost_fn) |
வெளியீடு:
[2320100 1330100 2950100]
[-679900 -669900 -549900]
[462264010000 448766010000 302390010000]
1213420030000
202236671666.66666
கணக்கிடு நிகழ்ந்த விதம்:
Cost function:
இது simple linear-ஐ ஒத்தே இருக்கும். ஆனால் h(x) கணக்கிடும் சூத்திரம் மட்டும் மாறுபடும்.
Gradient descent:
இதுவும் simple linear-ஐ ஒத்தே இருக்கும். ஆனால் simple linear-ல் தீட்டா0 மதிப்பு குறைக்கப்படுவதற்கான சமன்பாடில் x என்பது இருக்காது. ஆனால் இங்கு தீட்டா0 –வுடன் x0 சேர்க்கப்பட்டிருப்பதால், அனைத்து தீட்டா மதிப்புகள் குறைக்கப்படுவதற்கான சமன்பாடும் பின்வருமாறு ஒரே மாதிரியாகத்தான் இருக்கும்.
சூத்திரத்தின் மூலம் minimum cost கண்டறிதல்:
Gradient descent-ஐப் பயன்படுத்துவதற்கு பதிலாக பின்வரும் சமன்பாட்டின் மூலம் நேரடியாக நாம் minimum cost-ஐ ஏற்படுத்தக் கூடிய தீட்டாவை கண்டுபிடிக்க முடியும். ஆனால் features-ன் எண்ணிக்கை அதிகமாக இருந்தால், gradient descent–ஐப் பயன்படுத்துவதே சிறந்தது. ஏனெனில் மொத்த features-க்கும் அதனுடைய transpose கண்டுபிடிப்பது மிகுந்த நேர விரயம் செய்யக்கூடியதாக அமையும்.
Feature Scaling:
இங்கு ஒவ்வொரு feature-ம் வெவ்வேறு அளவிலான எண் வரிசைகளில் அமைந்திருப்பதைக் கவனிக்கவும். உதாரணத்துக்கு சதுர அடி என எடுத்துக் கொண்டால் அவை 800 முதல் 1200 வரையிலும், அறைகளின் எண்ணிக்கை என எடுத்துக்கொண்டால் அவை 2 முதல் 5 வரையிலும் பரவியுள்ளது.
சதுர அடி = 800, 1200, 2400
அறைகள் = 2, 3, 5
இவ்வாறு ஒவ்வொரு column-ல் உள்ள மதிப்புகளும் வெவ்வேறு எண் வரிசைகளில் இல்லாமல், அனைத்தும் -1 லிருந்து +1 வரை அல்லது 0 லிருந்து 1 வரை என normalize செய்வதே feature scaling எனப்படும். இதற்கு உதவுவதே mean normalization ஆகும். இதற்கான சூத்திரம் பின்வருமாறு.
particular value – mean of all values
————————————————–
maximum – minimum
சதுர அடி = (800 –1600)/(2400–800), (1200–1600)/(2400–800), (2400–1600)/(2400–800)
= -0.5 , 0.25, 0.5
அறைகள் = (2-3.5)/(5–2), (3-3.5)/(5–2), (5-3.5)/(5–2)
= -0.5 , -0.16, 0.5
இது போன்ற multiple linear-ல் gradient descent-ஐப் பயன்படுத்தும்போது ஒவ்வொரு feature-ம் ஒவ்வொரு அளவு வரிசைகளில் இருப்பதால் plot-ஆனது மிக மிகக் குறுகிய அளவு வட்டங்களை நெருக்க நெருக்கமாக ஏற்படுத்தும். எனவே மையத்தினை சென்றடைய மிகவும் சிரமப்படும். அதுவே normalize செய்யப்பட்டு அனைத்து வட்டங்களும் ஒரே அளவில் இருந்தால் மையத்தினை சென்றடைய வசதியாக இருக்கும்.