Principle Component Analysis என்பது அதிக அளவு பரிமாணங்கள் கொண்ட தரவுகளை குறைந்த அளவு பரிமாணங்கள் கொண்டதாக மாற்றுவதற்குப் பயன்படுகிறது. எடுத்துக்காட்டாக 1000 அம்சங்களைக் கொண்டு ஒரு விஷயம் கணிக்கப்படுகிறது என வைத்துக் கொள்வோம். PCA-ஆனது இந்த 1000 X-ஐ 100 X-ஆகவோ அல்லது இன்னும் குறைந்த பரிமாணங்கள் கொண்டதாகவோ மாற்றிக் கொடுக்கும். அதாவது Y எண்ணிக்கையைப் பற்றிக் கவலைப்படாது. வெறும் X எண்ணிக்கையை மட்டும் குறைக்கும். எனவேதான் PCA என்பது dimensionality reduction-க்கு உதவுகின்ற ஒரு சிறப்புவகை வழிமுறை ஆகும். இதன் செயல்பாடுகளில் உள்ள படிகள் பின்வருமாறு.
- முதலில் பயிற்சித் தரவுகளைப் பெற்றுக் கொள்ளுதல் (x1,y1),(x2,y2),(x3,y3)…
- அடுத்ததாக PCA மூலம் பயிற்சித் தரவில் உள்ள x அனைத்தையும் நமக்குத் தேவையான அளவு குறைந்த எண்ணிக்கையில் மாற்றுதல்
- பின்னர் குறைக்கப்பட்ட புதிய x -ஐக் கொண்டு பயிற்சி அளித்தல்
பொதுவாக இந்த PCA அனைத்து இடத்திலும் பயன்படாது. சற்று அரிதாகவே பயன்படும். எடுத்துக்காட்டுக்கு மனித முகங்கள் அல்லது ஊர்திகள் போன்றவற்றை அடையாளப்படுத்தும் algorithm-க்கு பயிற்சி அளிக்கப்படும் தரவுகளில் குறைந்தபட்சம் 1 லட்சம் features-ஆவது இருக்கும். ஏனெனில் ஒரு ஊர்தியின் சக்கரம், கைப்பிடி, இருக்கை, பக்கக் கண்ணாடிகள், முன் விளக்குகள் என்று ஒவ்வொரு சின்னச் சின்ன விஷயங்களையும் அடையாளப்படுத்த அதிக அளவில் features அமைந்திருக்கும். இதுபோன்ற இடங்களில் , அவை அனைத்தையும் பயன்படுத்தாமல் குறைந்த அளவில் features-ஐ மாற்றுவதற்கு PCA பயன்படுகிறது. எப்போதும் pca-ஐப் பயன்படுத்துவதற்கு முன்பு feature scaling என்ற ஒன்று கண்டிப்பாக நடைபெற வேண்டும். இதுவே data-preprocessing என்று அழைக்கப்படும்.
கீழ்க்கண்ட எடுத்துக்காட்டில் நாம் புரிந்து கொள்ளச் சுலபமாக இருக்க வேண்டும் என்பதற்காக 4 dimension கொண்ட தரவுகள் 2 dimension-ஆக PCA மூலம் மாற்றப்பட்டுள்ளது. PCA பயன்படுத்துவதற்கு முன்னர் StandardScalar மூலம் தரவுகள் normalize செய்யப்படுகின்றன. பின்னர் ஒரு மலர் மல்லியா, ரோஜாவா, தாமரையா என்று தீர்மானிக்க அவ்விதழ்களுடைய நீள அகலமும், அவற்றின் மேற்புற இதழ்களுடைய நீள அகலமுமாக 4 அம்சங்கள் உள்ளன. இவை PCA மூலம் x1, x2 எனும் இரண்டு அம்சங்களாக மாற்றப்படுகின்றன. இவ்விரண்டு அம்சங்களின் அடிப்படையில் அமையும் 3 வகை மலர்களும் 3 நிறங்களில் வரைபடமாக வரைந்து காட்டப்பட்டுள்ளது.
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 numpy as np | |
| import matplotlib.pyplot as plt | |
| import pandas as pd | |
| from sklearn.model_selection import train_test_split | |
| from sklearn.preprocessing import StandardScaler | |
| from sklearn.decomposition import PCA | |
| df = pd.read_csv('./flowers.csv') | |
| X = df[list(df.columns)[:-1]] | |
| y = df['Flower'] | |
| X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0) | |
| pca = PCA(n_components=2) | |
| x = StandardScaler().fit_transform(X_train) | |
| new_x = pd.DataFrame(data = pca.fit_transform(x), columns = ['x1', 'x2']) | |
| df2 = pd.concat([new_x, df[['Flower']]], axis = 1) | |
| fig = plt.figure(figsize = (8,8)) | |
| ax = fig.add_subplot(1,1,1) | |
| ax.set_xlabel('x1', fontsize = 15) | |
| ax.set_ylabel('x2', fontsize = 15) | |
| ax.set_title('2 Components', fontsize = 20) | |
| for i, j in zip(['Rose', 'Jasmin', 'Lotus'],['g', 'b', 'r']): | |
| ax.scatter(df2.loc[df2['Flower'] == i, 'x1'], df2.loc[df2['Flower'] == i, 'x2'], c = j) | |
| ax.legend(['Rose', 'Jasmin', 'Lotus']) | |
| ax.grid() | |
| plt.show() | |
| print (pca.explained_variance_ratio_) | |
| print (df.columns) | |
| print (df2.columns) |
வெளியீடு :
[0.72207932 0.24134489]
Index([‘Sepal_length’, ‘Sepal_width’, ‘Petal_length’, ‘Petal_width’, ‘Flower’], dtype=’object’)
Index([‘x1’, ‘x2’, ‘Flower’], dtype=’object’)
இதனுடைய வெளியீட்டில் என்பது explained variance என்பது [0.72207932 0.24134489] என வந்துள்ளது. இவ்விரண்டு மதிப்புகளையும் கூட்டினால் 0.96 என்று வரும். இதற்கு என்ன அர்த்தம் என்றால் இவ்விரண்டு components-ம் சேர்ந்து 96% தகவல்களை உள்ளடக்கியுள்ளது என்று அர்த்தம். ஏனெனில் features-ஐக் குறைக்கும்போது தகவல் இழப்பு ஏற்பட வாய்ப்பு உள்ளது. எனவே variance என்பது எவ்வளவு சதவீதம் தகவல்கள் ஒவ்வொன்றிலும் சேமிக்கப்பட்டுள்ளன என்பதைக் கூற உதவுகிறது. இதைப்பற்றியும், PCA செயல்படும் விதத்தையும் இன்னும் விளக்கமாகக் கீழே காணலாம்.
Data Projection:
தரவுகளின் பரிமாணங்களை குறைப்பதற்கு உதவும் திட்டமே Projection line அல்லது projection area எனப்படுகிறது. கீழ்க்கண்ட வரைபடங்களை கவனிக்கவும். இடதுபுறம் உள்ள படத்தில் 2 dimension கொண்ட தரவுகள் 1 dimension ஆக மாற்றப்படுவதற்கான திட்டம் உள்ளது. இதில் x1, x2 எனும் 2 அம்சங்களுக்கான scatter plot உள்ளது. அவற்றின் நடுவில் அமைந்துள்ள கோடுதான் projection-க்கான திசை ஆகும். இத்திசையை நோக்கியே தரவுகள் அனைத்தும் சென்று ஒரே பரிமாணம் கொண்டதாக மாற்றப்படுகின்றன. அவ்வாறே வலப்புறம் உள்ள படத்தில் x1, x2, x3 எனும் 3 அம்சங்களுக்கான தரவுகள் உள்ளது. அவற்றிற்கான projection area-ஆனது 2 பரிமாணங்களைக் கொண்டு வரைபடத்தில் காணப்படுவது போன்று அடையாளப்படுத்தப்படுகிறது. சுற்றியுள்ள தரவுகள் அனைத்தும் அப்பரப்பளவு கொண்ட பகுதிக்குள் சென்று 2 பரிமாணங்கள் கொண்ட வெக்டராக மாற்றப்படுகின்றன.
Projection Error:
மேற்கண்ட இரண்டு படங்களிலும் தரவுகள் அவை அமைந்துள்ள இடத்திற்கும், project செய்யப்பட்ட இடத்திற்குமான இடைவெளியே projection error என்று அழைக்கப்படுகிறது. 2d-ஐ 1d-ஆக மாற்றுவதற்கான படத்தைப் பார்க்கும்போது உங்களுக்கு linear regression நினைவுக்கு வரலாம். ஆனால் PCA என்பது linear regression அல்ல. ஏனெனில் நடுவில் உள்ள அக்கோடு prediction-க்குப் பயன்படாது. வெறும் projection-க்கு மட்டுமே பயன்படுகிறது. அவ்வாறே அக்கோட்டினை வைத்து Y மதிப்புகளை கணித்துச் சொல்லாது. வெறும் x மதிப்புகளை இடமாற்றம் செய்வதற்கே இக்கோடு பயன்படுகிறது. மேலும் linear regression-ல் sum of squares error என்பது இடைப்பட்ட தூரத்தை செங்குத்தாகக் கணக்கிடுகிறது. ஆனால் PCA-ல் projection error என்பது பக்கவாட்டில் கணக்கிடப்படுகிறது. இது பின்வருமாறு.
Compressed components:
அதிக அளவு கொண்ட பரிமாணங்கள் எவ்வாறு சிறிய அளவில் சுருக்கப்படுகிறது, அதில் உள்ள படிகள் என்னென்ன என்று பின்வருமாறு பார்க்கலாம்.
1. முதலில் தரவுகள் அனைத்தும் feature scaling செய்யப்பட வேண்டும். இதுவே data preprocessing என்று அழைக்கப்படுகிறது.(x1, x2, x3…xn)
2. அடுத்து features-க்கிடையேயான தரவுகள் எவ்வாறு அமைந்துள்ளன என்பதைக் காண covariance matrix உருவாக்கப்படுகிறது. இதற்கான வாய்ப்பாடு பின்வருமாறு. இதுவே sigma என்று அழைக்கப்படுகிறது.
covariance matrix / sigma = (1/m).summation of(1 to m)[x . transpose of x]
இந்த அணியானது symmetric positive definite எனும் பண்பு கொண்டுள்ளதா எனப் பார்க்க வேண்டும். அப்போதுதான் இதை வைத்து projection-க்கான வெக்டரை உருவாக்க முடியும்.
3. svd() அல்லது eig() எனும் function-ஐப் பயன்படுத்தி projection-க்கான வெக்டரை உருவாக்கலாம். இவை முறையே single value decomposition என்றும், eigenvector என்றும் அழைக்கப்படும். இது பின்வருமாறு
[u,s,v] = svd(sigma)
இது 3 அணிகளை உருவாக்கும். u என்பதுதான் projection -க்கான அணி. அதாவது u1, u2, u3…un வரை இருக்கும். இதிலிருந்து நமக்கு வேண்டிய அளவு features-ஐத் தேர்வு செய்யலாம். அதாவது u1, u2, u3…uk – இதில் k என்பது எவ்வளவு principle components என்பதைக் குறிக்கிறது. இதற்கான வாய்ப்பாடு பின்வருமாறு.
principle components = transpose of (u[: , 1:k]).x
4. அடுத்ததாக எவ்வளவு principle components இருந்தால் தகவல் இழப்பு எதுவும் இருக்காது என்பதைக் கண்டுபிடிக்க வேண்டும். இதைக் கண்டுபிடித்துக் கூறுவதே variance என்று அழைக்கப்படும். பொதுவாக 99% variance அளவில் இருக்குமாறு பார்த்துக் கொண்டால் நல்லது. எனவே k-ன் மதிப்பைக் கண்டுபிடிக்கும் வாய்ப்பாடானது பின்வருமாறு அமைகிறது.
Average squared projection error / Total variance in the data >= 0.99 (எனவே 99% அளவு variance-ஐ தக்க வைத்துக் கொள்கிறது)
Where,
Avg. squared projection error = (1/m).summation of(1 to m) . square of (x – projected x)
Total variance in the data = (1/m).summation of(1 to m) . square of (x)
k-ன் மதிப்பை ஒவ்வொன்றாக அதிகரித்து மேற்கண்ட வாய்ப்பாட்டில் பொருத்தி எப்போது அதன் மதிப்பு 0.99 ஐத் தாண்டுகிறது எனப் பார்ப்பது ஒரு வகை. இதற்கு பதிலாக svd()-யிலிருந்து பெறுகின்ற S அணியை பின்வரும் வாய்ப்பாட்டில் பொருத்தி k -ன் மதிப்பை நேரடியாகக் கண்டுபிடிக்கலாம்.
summation of(1 to k) S[i,j] / summation of(1 to m) S[i,j] >= 0.99
இவ்வாறாக அதிக அளவு கொண்ட பரிமாணங்கள் தகவல் இழப்பு எதுவும் நடைபெறாமல் குறைந்த அளவில் சுருக்கப்படுகிறது.