Python में प्रिंसिपल कॉम्पोनेंट एनालिसिस (PCA) कैसे करें

Principal component analysis (PCA) एक रैखिक आयामीय घटाव तकनीक है, जिसका उपयोग उच्च-आयामी स्पेस से जानकारी निकालने के लिए किया जा सकता है, उसे कम-आयामी उप-स्पेस पर प्रोजेक्ट करके। यदि आप रैखिक बीजगणित की भाषा से परिचित हैं, तो आप यह भी कह सकते हैं कि principal component analysis डेटा में अधिकतम विचरण की दिशाओं की पहचान करने के लिए सह-प्रसरण मैट्रिक्स के eigenvectors ढूंढना है।

PCA के बारे में एक महत्वपूर्ण बात यह है कि यह एक अनियंत्रित (unsupervised) आयामीय घटाव तकनीक है, इसलिए आप बिना किसी निगरानी (या लेबल) के, उनके बीच के सह-संबंध के आधार पर समान डेटा बिंदुओं को क्लस्टर कर सकते हैं।

ध्यान दें: Features, Dimensions, और Variables एक ही चीज़ को दर्शाते हैं। आप पाएंगे कि इन्हें परस्पर बदलकर इस्तेमाल किया जाता है।

आप PCA कहाँ लागू कर सकते हैं?

• डेटा विज़ुअलाइज़ेशन: किसी भी डेटा-संबंधी समस्या पर काम करते समय, आज की दुनिया में चुनौती डेटा की बहुतायत और उसे परिभाषित करने वाले वेरिएबल्स/फीचर्स की संख्या है। जहाँ डेटा कुंजी है, वहाँ समस्या हल करने के लिए व्यापक डेटा खोज-परख की ज़रूरत होती है, जैसे वेरिएबल्स के सह-संबंध को खोजना या कुछ वेरिएबल्स के वितरण को समझना। यह देखते हुए कि डेटा बहुत से वेरिएबल्स या आयामों के साथ वितरित है, विज़ुअलाइज़ेशन एक चुनौती बन सकता है और लगभग असंभव भी।

  ऐसे में, PCA आपके लिए यह काम कर सकता है क्योंकि यह डेटा को कम आयाम में प्रोजेक्ट करता है, जिससे आप 2D या 3D स्पेस में उसे सहज रूप से देख सकते हैं।

• मशीन लर्निंग (ML) एल्गोरिदम को तेज़ करना: चूँकि PCA का मुख्य विचार आयाम घटाना है, यदि आपके डेटा में बहुत सारे फीचर्स हैं और ML एल्गोरिदम की सीखने की प्रक्रिया बहुत धीमी है, तो आप प्रशिक्षण और परीक्षण समय को तेज़ करने के लिए PCA का लाभ उठा सकते हैं।

सार स्तर पर, आप अनेक फीचर्स वाले डेटा सेट को लेते हैं, और मूल फीचर्स में से कुछ Principal Components चुनकर उस डेटा सेट को सरल बनाते हैं।

Principal Component क्या है?

Principal components, PCA का मूल हैं; वे आपके डेटा के भीतर छिपी संरचना का प्रतिनिधित्व करते हैं। सरल शब्दों में, जब डेटा को उच्च आयाम से कम आयाम (मान लें तीन आयाम) में प्रोजेक्ट किया जाता है, तो वे तीन आयाम दरअसल तीन principal components ही होते हैं, जो आपके डेटा के अधिकांश विचरण (जानकारी) को कैप्चर करते हैं।

Principal components में दिशा और परिमाण दोनों होते हैं। दिशा यह दर्शाती है कि किस principal अक्ष के entlang डेटा सबसे अधिक फैला हुआ है या जिसमें सबसे अधिक विचरण है, और परिमाण यह बताता है कि उस अक्ष पर प्रोजेक्शन करने पर वह principal component डेटा के कितने विचरण को कैप्चर करता है। Principal components सीधी रेखाएँ होती हैं, और पहला principal component डेटा में सबसे अधिक विचरण को धारण करता है। प्रत्येक अगला principal component पिछले के लंबवत (orthogonal) होता है और उसमें कम विचरण होता है। इस प्रकार, y सैंपल्स पर दिए गए x सह-संबद्ध वेरिएबल्स के सेट से, आप उसी y सैंपल्स पर u असह-संबद्ध principal components का सेट प्राप्त करते हैं।

आपको मूल फीचर्स से असह-संबद्ध principal components इसलिए मिलते हैं क्योंकि सह-संबद्ध फीचर्स एक ही principal component में योगदान करते हैं, जिससे मूल डेटा फीचर्स घटकर असह-संबद्ध principal components में बदल जाते हैं; प्रत्येक, अलग-अलग सह-संबद्ध फीचर्स के सेट और विभिन्न मात्रा के परिवर्तनशीलता का प्रतिनिधित्व करता है। प्रत्येक principal component डेटा से कैप्चर की गई कुल परिवर्तनशीलता का एक प्रतिशत दर्शाता है।

आज के ट्यूटोरियल में, हम डेटा विज़ुअलाइज़ेशन के ज़रिए अंतर्दृष्टियाँ प्राप्त करने के लिए PCA लागू करेंगे, और हम अपने मशीन लर्निंग एल्गोरिदम को तेज़ करने के उद्देश्य से भी PCA लागू करेंगे। ऊपर बताए गए दोनों कार्यों को पूरा करने के लिए, आप दो प्रसिद्ध डेटा सेट इस्तेमाल करेंगे: Breast Cancer और CIFAR - 10। पहला संख्यात्मक डेटा सेट है; दूसरा इमेज डेटा सेट है। 

डेटा को समझना

डेटा लोड करने से पहले, यह समझना और देखना अच्छा है कि आप किस डेटा पर काम करने वाले हैं!

Breast Cancer

Breast Cancer डेटा सेट एक वास्तविक-मूल्य बहु-वेरिएट डेटा है जिसमें दो क्लास हैं, जहाँ प्रत्येक क्लास यह बताती है कि किसी मरीज को स्तन कैंसर है या नहीं। दो श्रेणियाँ हैं: malignant और benign।

malignant क्लास में 212 सैंपल हैं, जबकि benign क्लास में 357 सैंपल हैं।

इसमें सभी क्लास में साझा 30 फीचर्स हैं: radius, texture, perimeter, area, smoothness, fractal dimension, आदि।

आप breast cancer डेटा सेट को यहाँ से डाउनलोड कर सकते हैं, या और आसान तरीका है कि इसे sklearn लाइब्रेरी की मदद से लोड करें।

CIFAR - 10

CIFAR-10 (Canadian Institute For Advanced Research) डेटा सेट में 60000 इमेज होती हैं, प्रत्येक 32x32x3 रंगीन इमेज, और दस क्लास, प्रत्येक श्रेणी में 6000 इमेज।

डेटा सेट में 50000 प्रशिक्षण इमेज और 10000 परीक्षण इमेज होती हैं।

डेटा सेट में क्लास हैं: airplane, automobile, bird, cat, deer, dog, frog, horse, ship, truck।

आप CIFAR डेटा सेट को यहाँ से डाउनलोड कर सकते हैं, या Keras जैसी किसी डीप लर्निंग लाइब्रेरी की मदद से इसे ऑन-द-फ्लाई भी लोड कर सकते हैं।

PCA के साथ डेटा अन्वेषण

अब आप Breast Cancer और CIFAR-10 डेटा सेट लोड और विश्लेषित करेंगे। अब तक आपको दोनों डेटा सेट की आयामीयता के बारे में एक विचार हो गया होगा।

तो, आइए दोनों डेटा सेट को जल्दी से एक्सप्लोर करते हैं।

Breast cancer डेटा अन्वेषण

पहले Breast Cancer डेटा सेट को एक्सप्लोर करते हैं।

आप sklearn के मॉड्यूल datasets का उपयोग करेंगे और उसमें से Breast Cancer डेटा सेट इम्पोर्ट करेंगे।

from sklearn.datasets import load_breast_cancer

load_breast_cancer आपको लेबल और डेटा दोनों देगा। डेटा प्राप्त करने के लिए आप .data और लेबल प्राप्त करने के लिए .target कॉल करेंगे।

डेटा में 569 सैंपल और तीस फीचर्स हैं, और प्रत्येक सैंपल के साथ एक लेबल जुड़ा है। इस डेटा सेट में दो लेबल हैं।

breast = load_breast_cancer()

breast_data = breast.data

आइए डेटा का आकार जाँचें।

breast_data.shape

(569, 30)

हालाँकि इस ट्यूटोरियल के लिए आपको लेबल की ज़रूरत नहीं है, फिर भी बेहतर समझ के लिए लेबल लोड करते हैं और उनका आकार देखते हैं।

breast_labels = breast.target

breast_labels.shape

(569,)

अब आप numpy इम्पोर्ट करेंगे क्योंकि आप breast_labels को पुनर्रूपित (reshaping) करके breast_data के साथ जोड़ेंगे (concatenate), ताकि अंततः आप एक DataFrame बना सकें जिसमें डेटा और लेबल दोनों हों।

import numpy as np

labels = np.reshape(breast_labels,(569,1))

reshaping के बाद, आप डेटा और लेबल को दूसरे अक्ष के entlang concatenate करेंगे, जिसका मतलब है कि ऐरे का अंतिम आकार 569 x 31 होगा।

final_breast_data = np.concatenate([breast_data,labels],axis=1)

final_breast_data.shape

(569, 31)

अब आप pandas इम्पोर्ट करेंगे ताकि अंतिम डेटा का DataFrame बनाया जा सके और डेटा को सारणीबद्ध रूप में प्रस्तुत किया जा सके।

import pandas as pd

breast_dataset = pd.DataFrame(final_breast_data)

आइए जल्दी से वे फीचर्स प्रिंट करें जो breast cancer डेटा सेट में हैं!

features = breast.feature_names

features

array(['mean radius', 'mean texture', 'mean perimeter', 'mean area',
       'mean smoothness', 'mean compactness', 'mean concavity',
       'mean concave points', 'mean symmetry', 'mean fractal dimension',
       'radius error', 'texture error', 'perimeter error', 'area error',
       'smoothness error', 'compactness error', 'concavity error',
       'concave points error', 'symmetry error',
       'fractal dimension error', 'worst radius', 'worst texture',
       'worst perimeter', 'worst area', 'worst smoothness',
       'worst compactness', 'worst concavity', 'worst concave points',
       'worst symmetry', 'worst fractal dimension'], dtype='<U23')

यदि आप features ऐरे पर ध्यान दें, तो label फ़ील्ड गायब है। इसलिए, आपको इसे मैन्युअल रूप से features ऐरे में जोड़ना होगा क्योंकि आप इस ऐरे को अपने breast_dataset डेटा फ्रेम के कॉलम नामों के बराबर करेंगे।

features_labels = np.append(features,'label')

बहुत बढ़िया! अब आप breast_dataset डेटा फ्रेम में कॉलम नाम सेट करेंगे।

breast_dataset.columns = features_labels

आइए डेटा फ्रेम की शुरुआती कुछ पंक्तियाँ प्रिंट करें।

breast_dataset.head()

चूँकि मूल लेबल 0,1 फॉर्मेट में हैं, आप .replace फ़ंक्शन का इस्तेमाल करके लेबल को benign और malignant में बदल देंगे। आप inplace=True का उपयोग करेंगे, जो डेटा फ्रेम breast_dataset को संशोधित करेगा।

breast_dataset['label'].replace(0, 'Benign',inplace=True)
breast_dataset['label'].replace(1, 'Malignant',inplace=True)

आइए breast_dataset की अंतिम कुछ पंक्तियाँ प्रिंट करें।

breast_dataset.tail()

CIFAR - 10 डेटा अन्वेषण

अब, आप CIFAR - 10 इमेज डेटा सेट को एक्सप्लोर करेंगे

आप Keras नामक एक डीप लर्निंग लाइब्रेरी का उपयोग करके CIFAR - 10 डेटा सेट लोड कर सकते हैं।

from keras.datasets import cifar10

इम्पोर्ट करने के बाद, आप डेटा डाउनलोड करने के लिए .load_data() मेथड का उपयोग करेंगे, यह आपके Keras डायरेक्टरी में डेटा डाउनलोड और स्टोर कर देगा। आपकी इंटरनेट गति के आधार पर इसमें कुछ समय लग सकता है।

(x_train, y_train), (x_test, y_test) = cifar10.load_data()

ऊपर दी गई कोड लाइन प्रशिक्षण और परीक्षण इमेज के साथ उनके लेबल लौटाती है।

आइए प्रशिक्षण और परीक्षण इमेज का आकार जल्दी से प्रिंट करें।

print('Traning data shape:', x_train.shape)
print('Testing data shape:', x_test.shape)

Traning data shape: (50000, 32, 32, 3)
Testing data shape: (10000, 32, 32, 3)

आइए लेबल्स का आकार भी प्रिंट करें।

y_train.shape,y_test.shape

((50000, 1), (10000, 1))

आइए कुल लेबल्स की संख्या और डेटा में मौजूद विभिन्न प्रकार की क्लास भी जान लें।

# Find the unique numbers from the train labels
classes = np.unique(y_train)
nClasses = len(classes)
print('Total number of outputs : ', nClasses)
print('Output classes : ', classes)

Total number of outputs :  10
Output classes :  [0 1 2 3 4 5 6 7 8 9]

अब CIFAR-10 इमेज को प्लॉट करने के लिए, आप matplotlib इम्पोर्ट करेंगे और एक मैजिक (%) कमांड %matplotlib inline का उपयोग करेंगे ताकि जूपिटर नोटबुक आउटपुट को यहीं दिखाए!

import matplotlib.pyplot as plt
%matplotlib inline

बेहतर समझ के लिए, चलिए एक डिक्शनरी बनाते हैं जिसमें क्लास नाम उनके संबंधित श्रेणीबद्ध क्लास लेबल्स के साथ होंगे।

label_dict = {
 0: 'airplane',
 1: 'automobile',
 2: 'bird',
 3: 'cat',
 4: 'deer',
 5: 'dog',
 6: 'frog',
 7: 'horse',
 8: 'ship',
 9: 'truck',
}

plt.figure(figsize=[5,5])

# Display the first image in training data
plt.subplot(121)
curr_img = np.reshape(x_train[0], (32,32,3))
plt.imshow(curr_img)
print(plt.title("(Label: " + str(label_dict[y_train[0][0]]) + ")"))

# Display the first image in testing data
plt.subplot(122)
curr_img = np.reshape(x_test[0],(32,32,3))
plt.imshow(curr_img)
print(plt.title("(Label: " + str(label_dict[y_test[0][0]]) + ")"))

Text(0.5, 1.0, '(Label: frog)')
Text(0.5, 1.0, '(Label: cat)')

ऊपर की दोनों इमेज धुंधली होने के बावजूद, आप फिर भी देख सकते हैं कि पहली इमेज एक मेंढक की है जिसका लेबल frog है, जबकि दूसरी इमेज एक बिल्ली की है जिसका लेबल cat है।

PCA के जरिए डेटा विज़ुअलाइज़ेशन

अब आता है इस ट्यूटोरियल का सबसे रोचक भाग। जैसा कि आपने पहले सीखा, PCA उच्च-आयामी डेटा को कम-आयामी principal component में प्रोजेक्ट करता है; अब समय है इसे Python की मदद से विज़ुअलाइज़ करने का!

Breast cancer डेटा का विज़ुअलाइज़ेशन

• आप डेटा को Standardizing करके शुरू करेंगे क्योंकि PCA का आउटपुट डेटा के फीचर्स के स्केल से प्रभावित होता है।

  किसी भी मशीन लर्निंग एल्गोरिदम को देने से पहले अपने डेटा को normalize करना आम प्रथा है।

  Normalization लागू करने के लिए, आप sklearn लाइब्रेरी से StandardScaler मॉड्यूल इम्पोर्ट करेंगे और Data Exploration चरण में बनाए गए breast_dataset से केवल फीचर्स का चयन करेंगे। फीचर्स मिलने के बाद, आप फीचर डेटा पर fit_transform करके स्केलिंग लागू करेंगे।

  StandardScaler लागू करते समय, आपके डेटा का प्रत्येक फीचर सामान्य वितरण (normally distributed) होना चाहिए ताकि यह वितरण को शून्य माध्य (mean) और एक मानक विचलन (standard deviation) पर स्केल कर दे।

from sklearn.preprocessing import StandardScaler
x = breast_dataset.loc[:, features].values
x = StandardScaler().fit_transform(x) # normalizing the features

x.shape

(569, 30)

आइए जाँचें कि normalized डेटा का माध्य शून्य और मानक विचलन एक है या नहीं।

np.mean(x),np.std(x)

(-6.826538293184326e-17, 1.0)

आइए normalized फीचर्स को DataFrame की मदद से सारणीबद्ध रूप में बदलें।

feat_cols = ['feature'+str(i) for i in range(x.shape[1])]

normalised_breast = pd.DataFrame(x,columns=feat_cols)

normalised_breast.tail()

• अब आता है महत्वपूर्ण भाग; अगली कुछ कोड लाइनों में तीस-आयामी Breast Cancer डेटा को दो-आयामी principal components में प्रोजेक्ट किया जाएगा।

  आप sklearn लाइब्रेरी का उपयोग करके PCA मॉड्यूल इम्पोर्ट करेंगे, और PCA मेथड में आप कंपोनेंट्स की संख्या (n_components=2) पास करेंगे और अंत में समग्र डेटा पर fit_transform कॉल करेंगे। यहाँ, components की संख्या उस कम आयाम का प्रतिनिधित्व करती है जिसमें आप अपने उच्च-आयामी डेटा को प्रोजेक्ट करेंगे।

from sklearn.decomposition import PCA
pca_breast = PCA(n_components=2)
principalComponents_breast = pca_breast.fit_transform(x)

अगला, एक DataFrame बनाते हैं जिसमें सभी 569 सैंपल्स के principal component मान होंगे।

principal_breast_Df = pd.DataFrame(data = principalComponents_breast
             , columns = ['principal component 1', 'principal component 2'])

principal_breast_Df.tail()

• एक बार आपके पास principal components आ जाएँ, तो आप explained_variance_ratio निकाल सकते हैं। यह आपको यह बताएगा कि डेटा को कम-आयामी उप-स्पेस में प्रोजेक्ट करने के बाद प्रत्येक principal component में कितनी जानकारी या विचरण निहित है।

print('Explained variability per principal component: {}'.format(pca_breast.explained_variance_ratio_))

Explained variability per principal component: [0.44272026 0.18971182]

ऊपर के आउटपुट से आप देख सकते हैं कि principal component 1 44.2% जानकारी रखता है, जबकि principal component 2 केवल 19% जानकारी रखता है। एक और बात ध्यान देने की है कि तीस-आयामी डेटा को दो-आयामी डेटा में प्रोजेक्ट करते समय 36.8% जानकारी खो गई।

आइए 569 सैंपल्स का principal component - 1 और principal component - 2 अक्षों के entlang विज़ुअलाइज़ेशन प्लॉट करें। इससे आपको इस बात की अच्छी समझ मिलेगी कि आपके सैंपल्स दो क्लास में कैसे वितरित हैं।

plt.figure()
plt.figure(figsize=(10,10))
plt.xticks(fontsize=12)
plt.yticks(fontsize=14)
plt.xlabel('Principal Component - 1',fontsize=20)
plt.ylabel('Principal Component - 2',fontsize=20)
plt.title("Principal Component Analysis of Breast Cancer Dataset",fontsize=20)
targets = ['Benign', 'Malignant']
colors = ['r', 'g']
for target, color in zip(targets,colors):
    indicesToKeep = breast_dataset['label'] == target
    plt.scatter(principal_breast_Df.loc[indicesToKeep, 'principal component 1']
               , principal_breast_Df.loc[indicesToKeep, 'principal component 2'], c = color, s = 50)

plt.legend(targets,prop={'size': 15})

<matplotlib.legend.Legend at 0x14552a630>




<Figure size 432x288 with 0 Axes>

ऊपर के ग्राफ से आप देख सकते हैं कि benign और malignant ये दो क्लास, जब दो-आयामी स्पेस में प्रोजेक्ट की जाती हैं, तो कुछ हद तक रैखिक रूप से विभेद्य (linearly separable) हो सकती हैं। एक अन्य अवलोकन यह हो सकता है कि benign क्लास, malignant क्लास की तुलना में अधिक फैली हुई है।

CIFAR - 10 डेटा का विज़ुअलाइज़ेशन

CIFAR-10 डेटा को विज़ुअलाइज़ करने के लिए निम्नलिखित कोड लाइनें, Breast Cancer डेटा के PCA विज़ुअलाइज़ेशन के काफ़ी समान हैं।

• आइए जल्दी से CIFAR-10 प्रशिक्षण इमेज के अधिकतम और न्यूनतम मान जाँचें और पिक्सेल को 0 और 1 (समावेशी) के बीच normalize करें।

np.min(x_train),np.max(x_train)

(0.0, 1.0)

x_train = x_train/255.0

np.min(x_train),np.max(x_train)

(0.0, 0.00392156862745098)

x_train.shape

(50000, 32, 32, 3)

अगला, आप एक DataFrame बनाएँगे जो इमेज के पिक्सेल मानों और उनके संबंधित लेबल्स को पंक्ति-कॉलम प्रारूप में रखेगा।

लेकिन उससे पहले, आइए इमेज आयामों को तीन से एक में बदलें (इमेज को flatten करें)।

x_train_flat = x_train.reshape(-1,3072)

feat_cols = ['pixel'+str(i) for i in range(x_train_flat.shape[1])]

df_cifar = pd.DataFrame(x_train_flat,columns=feat_cols)

df_cifar['label'] = y_train
print('Size of the dataframe: {}'.format(df_cifar.shape))

Size of the dataframe: (50000, 3073)

उत्तम! डेटा फ्रेम का आकार सही है क्योंकि 50,000 प्रशिक्षण इमेज हैं, प्रत्येक में 3072 पिक्सेल हैं और लेबल के लिए एक अतिरिक्त कॉलम, यानी कुल 3073।

PCA सभी कॉलम्स पर लागू होगा, सिवाय अंतिम के, जो प्रत्येक इमेज का लेबल है।

df_cifar.head()

• अगला, आप PCA मेथड बनाएँगे और कंपोनेंट्स की संख्या दो देंगे और प्रशिक्षण डेटा पर fit_transform लागू करेंगे; इसमें कुछ सेकंड लग सकते हैं क्योंकि 50,000 सैंपल हैं

pca_cifar = PCA(n_components=2)
principalComponents_cifar = pca_cifar.fit_transform(df_cifar.iloc[:,:-1])

उसके बाद आप 50,000 इमेज में से प्रत्येक के principal components को numpy ऐरे से pandas DataFrame में बदल देंगे।

principal_cifar_Df = pd.DataFrame(data = principalComponents_cifar
             , columns = ['principal component 1', 'principal component 2'])
principal_cifar_Df['y'] = y_train

principal_cifar_Df.head()

• आइए जल्दी से जानें कि principal components कितनी जानकारी या variance धारण करते हैं।

print('Explained variability per principal component: {}'.format(pca_cifar.explained_variance_ratio_))

Explained variability per principal component: [0.2907663  0.11253144]

ठीक है, ऐसा लगता है कि principal components 1 और 2 ने ठीक-ठाक मात्रा में जानकारी बरकरार रखी है, जबकि डेटा को 3072 आयामों से घटाकर केवल दो principal components में प्रोजेक्ट किया गया था।

अब समय है CIFAR-10 डेटा को दो-आयामी स्पेस में विज़ुअलाइज़ करने का। याद रखें कि इस डेटा सेट में कुछ सार्थक क्लास-ओवरलैप है, जिसका मतलब है कि मेंढक का आकार बिल्ली या हिरण का कुत्ते से थोड़ा मिलता-जुलता हो सकता है; खासकर जब दो-आयामी स्पेस में प्रोजेक्ट किया जाए। उनके बीच के अंतर उतने अच्छे से कैप्चर नहीं हो सकते।

import seaborn as sns
plt.figure(figsize=(16,10))
sns.scatterplot(
    x="principal component 1", y="principal component 2",
    hue="y",
    palette=sns.color_palette("hls", 10),
    data=principal_cifar_Df,
    legend="full",
    alpha=0.3
)

<matplotlib.axes._subplots.AxesSubplot at 0x12a5ba8d0>

ऊपर दी गई फ़िगर से आप देख सकते हैं कि principal components ने कुछ विचरण कैप्चर किया है क्योंकि दो principal component अक्षों के entlang प्रोजेक्ट करने पर बिंदुओं में कुछ संरचना दिखाई देती है। एक ही क्लास के बिंदु एक-दूसरे के क़रीब हैं, और जो बिंदु या इमेज अर्थगत रूप से बहुत भिन्न हैं, वे एक-दूसरे से दूर हैं।

CIFAR-10 डेटा सेट के साथ PCA का उपयोग करके डीप लर्निंग प्रशिक्षण तेज़ करें

ट्यूटोरियल के इस अंतिम हिस्से में, आप सीखेंगे कि आप PCA का उपयोग करके अपने Deep Learning मॉडल के प्रशिक्षण को कैसे तेज़ कर सकते हैं।

नोट: इस खंड में उपयोग होने वाली बुनियादी पारिभाषिक शब्दावली सीखने के लिए, निःसंकोच यह ट्यूटोरियल देखें।

सबसे पहले, प्रशिक्षण और परीक्षण इमेज को normalize करें। यदि आपको याद हो, प्रशिक्षण इमेज को PCA विज़ुअलाइज़ेशन भाग में normalize किया गया था, इसलिए अब केवल परीक्षण इमेज को normalize करने की आवश्यकता है। तो, इसे जल्दी से कर लेते हैं!

x_test = x_test/255.0

x_test = x_test.reshape(-1,32,32,3)

आइए परीक्षण डेटा को reshape करें।

x_test_flat = x_test.reshape(-1,3072)

अब, आप PCA मॉडल का इंस्टैंस बनाएंगे।

यहाँ, आप यह भी पास कर सकते हैं कि PCA कितनी variance कैप्चर करे। आइए PCA मॉडल को पैरामीटर के रूप में 0.9 पास करें, जिसका अर्थ है कि PCA 90% variance को रखेगा और 90% variance कैप्चर करने के लिए आवश्यक number of components का उपयोग किया जाएगा।

ध्यान दें कि पहले आपने पैरामीटर के रूप में n_components पास किया था और तब आप पता लगा सकते थे कि उन दो कॉम्पोनेंट्स ने कितनी variance कैप्चर की। लेकिन यहाँ हम स्पष्ट रूप से बताते हैं कि PCA कितनी variance कैप्चर करे, और इसलिए n_components variance पैरामीटर के आधार पर बदलता रहेगा।

यदि आप कोई variance पास नहीं करते हैं, तो कॉम्पोनेंट्स की संख्या डेटा के मूल डायमेंशन के बराबर होगी।

pca = PCA(0.9)

इसके बाद आप प्रशिक्षण इमेज पर PCA इंस्टैंस को fit करेंगे।

pca.fit(x_train_flat)

PCA(copy=True, iterated_power='auto', n_components=0.9, random_state=None,
  svd_solver='auto', tol=0.0, whiten=False)

अब देखते हैं कि 0.9 variance कैप्चर करने के लिए PCA ने कितने n_components उपयोग किए।

pca.n_components_

99

ऊपर के आउटपुट से आप देख सकते हैं कि 90% variance हासिल करने के लिए, मूल 3072 डायमेंशंस से घटाकर 99 प्रिंसिपल कॉम्पोनेंट्स तक डायमेंशन कम कर दिया गया।

अंत में, आप fit मेथड से जनरेट पैरामीटर्स के आधार पर ट्रांसफॉर्म्ड डेटासेट बनाने के लिए प्रशिक्षण और परीक्षण दोनों सेट पर transform लागू करेंगे।

train_img_pca = pca.transform(x_train_flat)
test_img_pca = pca.transform(x_test_flat)

आगे, डीप लर्निंग मॉडल चलाने के लिए आवश्यक लाइब्रेरीज़ को जल्दी से इंपोर्ट करें।

from keras.models import Sequential
from keras.layers import Dense
from keras.utils import np_utils
from keras.optimizers import RMSprop

अब, आप अपने प्रशिक्षण और परीक्षण लेबल्स को one-hot एन्कोडिंग वेक्टर में बदलेंगे।

y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)

आइए अपने मॉडल के लिए epochs की संख्या, क्लासेस की संख्या, और batch size परिभाषित करें।

batch_size = 128
num_classes = 10
epochs = 20

अब, आप अपना Sequential मॉडल परिभाषित करेंगे!

model = Sequential()
model.add(Dense(1024, activation='relu', input_shape=(99,)))
model.add(Dense(1024, activation='relu'))
model.add(Dense(512, activation='relu'))
model.add(Dense(256, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))

मॉडल सारांश प्रिंट करें।

model.summary()

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_1 (Dense)              (None, 1024)              102400    
_________________________________________________________________
dense_2 (Dense)              (None, 1024)              1049600   
_________________________________________________________________
dense_3 (Dense)              (None, 512)               524800    
_________________________________________________________________
dense_4 (Dense)              (None, 256)               131328    
_________________________________________________________________
dense_5 (Dense)              (None, 10)                2570      
=================================================================
Total params: 1,810,698
Trainable params: 1,810,698
Non-trainable params: 0
_________________________________________________________________

आखिरकार, मॉडल को compile और train करने का समय आ गया है!

model.compile(loss='categorical_crossentropy',
              optimizer=RMSprop(),
              metrics=['accuracy'])

history = model.fit(train_img_pca, y_train,batch_size=batch_size,epochs=epochs,verbose=1,
                    validation_data=(test_img_pca, y_test))

WARNING:tensorflow:From /Users/adityasharma/blog/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:2704: calling reduce_sum (from tensorflow.python.ops.math_ops) with keep_dims is deprecated and will be removed in a future version.
Instructions for updating:
keep_dims is deprecated, use keepdims instead
WARNING:tensorflow:From /Users/adityasharma/blog/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:1257: calling reduce_mean (from tensorflow.python.ops.math_ops) with keep_dims is deprecated and will be removed in a future version.
Instructions for updating:
keep_dims is deprecated, use keepdims instead
Train on 50000 samples, validate on 10000 samples
Epoch 1/20
50000/50000 [==============================] - 7s - loss: 1.9032 - acc: 0.2962 - val_loss: 1.6925 - val_acc: 0.3875
Epoch 2/20
50000/50000 [==============================] - 7s - loss: 1.6480 - acc: 0.4055 - val_loss: 1.5313 - val_acc: 0.4412
Epoch 3/20
50000/50000 [==============================] - 7s - loss: 1.5205 - acc: 0.4534 - val_loss: 1.4609 - val_acc: 0.4695
Epoch 4/20
50000/50000 [==============================] - 7s - loss: 1.4322 - acc: 0.4849 - val_loss: 1.6164 - val_acc: 0.4503
Epoch 5/20
50000/50000 [==============================] - 7s - loss: 1.3621 - acc: 0.5120 - val_loss: 1.3626 - val_acc: 0.5081
Epoch 6/20
50000/50000 [==============================] - 7s - loss: 1.2995 - acc: 0.5330 - val_loss: 1.4100 - val_acc: 0.4940
Epoch 7/20
50000/50000 [==============================] - 7s - loss: 1.2473 - acc: 0.5529 - val_loss: 1.3589 - val_acc: 0.5251
Epoch 8/20
50000/50000 [==============================] - 7s - loss: 1.2010 - acc: 0.5669 - val_loss: 1.3315 - val_acc: 0.5232
Epoch 9/20
50000/50000 [==============================] - 7s - loss: 1.1524 - acc: 0.5868 - val_loss: 1.3903 - val_acc: 0.5197
Epoch 10/20
50000/50000 [==============================] - 7s - loss: 1.1134 - acc: 0.6013 - val_loss: 1.2722 - val_acc: 0.5499
Epoch 11/20
50000/50000 [==============================] - 7s - loss: 1.0691 - acc: 0.6160 - val_loss: 1.5911 - val_acc: 0.4768
Epoch 12/20
50000/50000 [==============================] - 7s - loss: 1.0325 - acc: 0.6289 - val_loss: 1.2515 - val_acc: 0.5602
Epoch 13/20
50000/50000 [==============================] - 7s - loss: 0.9977 - acc: 0.6420 - val_loss: 1.5678 - val_acc: 0.4914
Epoch 14/20
50000/50000 [==============================] - 8s - loss: 0.9567 - acc: 0.6567 - val_loss: 1.3525 - val_acc: 0.5418
Epoch 15/20
50000/50000 [==============================] - 9s - loss: 0.9158 - acc: 0.6713 - val_loss: 1.3525 - val_acc: 0.5540
Epoch 16/20
50000/50000 [==============================] - 10s - loss: 0.8948 - acc: 0.6816 - val_loss: 1.5633 - val_acc: 0.5156
Epoch 17/20
50000/50000 [==============================] - 9s - loss: 0.8690 - acc: 0.6903 - val_loss: 1.6980 - val_acc: 0.5084
Epoch 18/20
50000/50000 [==============================] - 9s - loss: 0.8586 - acc: 0.7002 - val_loss: 1.6325 - val_acc: 0.5247
Epoch 19/20
50000/50000 [==============================] - 8s - loss: 0.9367 - acc: 0.6853 - val_loss: 1.8253 - val_acc: 0.5165
Epoch 20/20
50000/50000 [==============================] - 8s - loss: 2.3761 - acc: 0.5971 - val_loss: 6.0192 - val_acc: 0.4409

ऊपर के आउटपुट से आप देख सकते हैं कि CPU पर प्रत्येक epoch को ट्रेन करने में केवल 7 seconds लगे। मॉडल ने प्रशिक्षण डेटा पर ठीक-ठाक प्रदर्शन किया, जहाँ उसने 70% सटीकता हासिल की, जबकि परीक्षण डेटा पर केवल 56% सटीकता मिली। इसका अर्थ है कि इसने प्रशिक्षण डेटा पर overfit किया। फिर भी याद रखें कि डेटा को 3072 डायमेंशंस से घटाकर 99 डायमेंशंस पर प्रोजेक्ट किया गया था, और इसके बावजूद इसने अच्छा काम किया!

अंत में, देखते हैं कि वही डीप लर्निंग मॉडल मूल डेटासेट पर ट्रेन होने में कितना समय लेता है और कितनी सटीकता प्राप्त कर सकता है।

model = Sequential()
model.add(Dense(1024, activation='relu', input_shape=(3072,)))
model.add(Dense(1024, activation='relu'))
model.add(Dense(512, activation='relu'))
model.add(Dense(256, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy',
              optimizer=RMSprop(),
              metrics=['accuracy'])

history = model.fit(x_train_flat, y_train,batch_size=batch_size,epochs=epochs,verbose=1,
                    validation_data=(x_test_flat, y_test))

Train on 50000 samples, validate on 10000 samples
Epoch 1/20
50000/50000 [==============================] - 23s - loss: 2.0657 - acc: 0.2200 - val_loss: 2.0277 - val_acc: 0.2485
Epoch 2/20
50000/50000 [==============================] - 22s - loss: 1.8727 - acc: 0.3166 - val_loss: 1.8428 - val_acc: 0.3215
Epoch 3/20
50000/50000 [==============================] - 22s - loss: 1.7801 - acc: 0.3526 - val_loss: 1.7657 - val_acc: 0.3605
Epoch 4/20
50000/50000 [==============================] - 22s - loss: 1.7141 - acc: 0.3796 - val_loss: 1.6345 - val_acc: 0.4132
Epoch 5/20
50000/50000 [==============================] - 22s - loss: 1.6566 - acc: 0.4001 - val_loss: 1.6384 - val_acc: 0.4076
Epoch 6/20
50000/50000 [==============================] - 22s - loss: 1.6083 - acc: 0.4209 - val_loss: 1.7507 - val_acc: 0.3574
Epoch 7/20
50000/50000 [==============================] - 22s - loss: 1.5626 - acc: 0.4374 - val_loss: 1.7125 - val_acc: 0.4010
Epoch 8/20
50000/50000 [==============================] - 22s - loss: 1.5252 - acc: 0.4486 - val_loss: 1.5914 - val_acc: 0.4321
Epoch 9/20
50000/50000 [==============================] - 24s - loss: 1.4924 - acc: 0.4620 - val_loss: 1.5352 - val_acc: 0.4616
Epoch 10/20
50000/50000 [==============================] - 25s - loss: 1.4627 - acc: 0.4728 - val_loss: 1.4561 - val_acc: 0.4798
Epoch 11/20
50000/50000 [==============================] - 24s - loss: 1.4349 - acc: 0.4820 - val_loss: 1.5044 - val_acc: 0.4723
Epoch 12/20
50000/50000 [==============================] - 24s - loss: 1.4120 - acc: 0.4919 - val_loss: 1.4740 - val_acc: 0.4790
Epoch 13/20
50000/50000 [==============================] - 23s - loss: 1.3913 - acc: 0.4981 - val_loss: 1.4430 - val_acc: 0.4891
Epoch 14/20
50000/50000 [==============================] - 27s - loss: 1.3678 - acc: 0.5098 - val_loss: 1.4323 - val_acc: 0.4888
Epoch 15/20
50000/50000 [==============================] - 27s - loss: 1.3508 - acc: 0.5148 - val_loss: 1.6179 - val_acc: 0.4372
Epoch 16/20
50000/50000 [==============================] - 25s - loss: 1.3443 - acc: 0.5167 - val_loss: 1.5868 - val_acc: 0.4656
Epoch 17/20
50000/50000 [==============================] - 25s - loss: 1.3734 - acc: 0.5101 - val_loss: 1.4756 - val_acc: 0.4913
Epoch 18/20
50000/50000 [==============================] - 26s - loss: 5.5126 - acc: 0.3591 - val_loss: 5.7580 - val_acc: 0.3084
Epoch 19/20
50000/50000 [==============================] - 27s - loss: 5.6346 - acc: 0.3395 - val_loss: 3.7362 - val_acc: 0.3402
Epoch 20/20
50000/50000 [==============================] - 26s - loss: 6.4199 - acc: 0.3030 - val_loss: 13.9429 - val_acc: 0.1326

Voilà! ऊपर के आउटपुट से यह स्पष्ट है कि CPU पर प्रत्येक epoch को ट्रेन करने में लगभग 23 seconds लगे, जो PCA आउटपुट पर ट्रेंड मॉडल की तुलना में लगभग तीन गुना अधिक था।

साथ ही, प्रशिक्षण और परीक्षण—दोनों—की सटीकता, उन 99 प्रिंसिपल कॉम्पोनेंट्स को इनपुट देने पर मिली सटीकता से कम रही।

तो, प्रशिक्षण डेटा पर PCA लागू करके, आप अपने डीप लर्निंग एल्गोरिथ्म को न केवल तेजी से ट्रेन कर पाए, बल्कि मूल प्रशिक्षण डेटा पर ट्रेंड डीप लर्निंग एल्गोरिथ्म की तुलना में परीक्षण डेटा पर बेहतर सटीकता भी हासिल की।

और आगे बढ़ें!

ट्यूटोरियल पूरा करने पर बधाई।

यह ट्यूटोरियल Python में PCA का उत्कृष्ट और विस्तृत परिचय था, जिसमें सैद्धांतिक और व्यावहारिक—दोनों—पहलुओं को शामिल किया गया।

यदि आप dimensionality reduction तकनीकों में और गहराई से जाना चाहते हैं, तो t-distributed Stochastic Neighbor Embedding, जिसे आमतौर पर tSNE कहा जाता है, के बारे में पढ़ें; यह एक non-linear probabilistic dimensionality reduction तकनीक है।

यदि आप PCA जैसी unsupervised learning तकनीकों के बारे में और सीखना चाहते हैं, तो DataCamp का Unsupervised Learning in Python कोर्स करें।

आगे सीखने के लिए संदर्भ:

• Sklearn में PCA
• R में प्रिंसिपल कॉम्पोनेंट एनालिसिस
• Python (scikit-learn) के साथ PCA