Dimensionality Reduction को समझना

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

इस ट्यूटोरियल में, हम जानेंगे कि आयाम-घटाव का उपयोग क्यों करना चाहिए, आयाम-घटाव तकनीकों के प्रकार क्या हैं, और इन तकनीकों को एक सरल इमेज डेटासेट पर कैसे लागू करें। हम डेटा को 2D स्पेस में भी विज़ुअलाइज़ करेंगे और कम-आयामी स्पेस में इमेज की तुलना करेंगे।

यदि आप मशीन लर्निंग में नए हैं और इसके कॉन्सेप्ट्स में महारत हासिल करना चाहते हैं, तो Become a Machine Learning Scientist in Python करियर ट्रैक करें और मशीन लर्निंग साइंटिस्ट बनने की दिशा में आगे बढ़ें।

छवि: लेखक द्वारा

आयाम-घटाव क्यों?

उच्च-आयामी डेटा, जानकारी में समृद्ध होने के बावजूद, अक्सर अनावश्यक या अप्रासंगिक फीचर्स भी रखता है। इससे कई समस्याएँ हो सकती हैं:

1. आयामों का अभिशाप: जैसे-जैसे आयामों की संख्या बढ़ती है, डेटा बिंदु विरल होते जाते हैं, जिससे मशीन लर्निंग मॉडलों के लिए पैटर्न खोजना कठिन हो जाता है।
2. ओवरफिटिंग: उच्च-आयामी डेटासेट मॉडल्स में ओवरफिटिंग करा सकते हैं, क्योंकि वे मूल पैटर्न की बजाय शोर सीख सकते हैं।
3. संगणनात्मक जटिलता: अधिक आयामों का मतलब अधिक कंप्यूटेशनल लागत, जो प्रशिक्षण और इन्फरेंस को धीमा कर सकती है।
4. विज़ुअलाइज़ेशन चुनौतियाँ: तीन से अधिक आयामों वाले डेटा का विज़ुअलाइज़ेशन करना डेटा की संरचना को समझना कठिन बना देता है।

आयाम-घटाव इन समस्याओं का समाधान डेटा को सरल बनाकर करता है, जबकि उसके सबसे महत्वपूर्ण फीचर्स बनाए रखता है। इससे न केवल मॉडल का प्रदर्शन सुधरता है, बल्कि डेटा को समझना और विज़ुअलाइज़ करना भी आसान हो जाता है।

रेखीय बनाम गैर-रेखीय आयाम-घटाव

आयाम-घटाव तकनीकों को इस आधार पर भी वर्गीकृत किया जा सकता है कि वे डेटा में रैखिक या गैर-रैखिक संरचना मानती हैं।

रेखीय विधियाँ

रेखीय विधियाँ मानती हैं कि डेटा किसी रैखिक उप-अंतरिक्ष में स्थित है। ये तकनीकें संगणनात्मक रूप से कुशल होती हैं और तब अच्छी तरह काम करती हैं जब डेटा की संरचना स्वभावतः रैखिक हो। 

कुछ उदाहरण इस प्रकार हैं:

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

इस Principal Component Analysis (PCA) in Python ट्यूटोरियल का अनुसरण करें और Breast Cancer तथा CIFAR-10 डेटासेट का उपयोग करके बिना सुपरविजन के डेटा से जानकारी निकालना सीखें। 

गैर-रेखीय विधियाँ

गैर-रेखीय विधियाँ तब इस्तेमाल होती हैं जब डेटा किसी गैर-रेखीय मैनिफोल्ड पर स्थित होता है। ये तकनीकें डेटा में जटिल संरचनाओं को कैप्चर करने के लिए बेहतर होती हैं। 

कुछ उदाहरण इस प्रकार हैं:

• t-SNE (t-Distributed Stochastic Neighbor Embedding): उच्च-आयामी डेटा को 2D या 3D में विज़ुअलाइज़ करने की एक लोकप्रिय विधि, जो डेटा बिंदुओं के बीच स्थानीय संबंधों को सुरक्षित रखने में प्रभावी होती है। अधिक जानने के लिए हमारा t-SNE मार्गदर्शक पढ़ें।
• UMAP (Uniform Manifold Approximation and Projection): यह t-SNE के समान है, लेकिन तेज़ है और वैश्विक संरचना को सुरक्षित रखने में बेहतर है।
• ऑटोएन्कोडर: बिना सुपरविजन वाले लर्निंग का उपयोग करके डेटा के निरूपण को संपीड़ित करने के लिए न्यूरल नेटवर्क का उपयोग किया जाता है।

आयाम-घटाव के प्रकार

आयाम-घटाव तकनीकों को व्यापक रूप से दो प्रकारों में वर्गीकृत किया जा सकता है: फीचर चयन और फीचर निष्कर्षण।

फीचर चयन

फीचर चयन में डेटासेट से केवल सबसे प्रासंगिक फीचर्स की पहचान कर उन्हें बनाए रखना शामिल है। यह प्रक्रिया डेटा को रूपांतरित नहीं करती, बल्कि मूल फीचर्स का एक उपसमुच्चय चुनती है। 

सामान्य विधियों में शामिल हैं:

• फ़िल्टर विधियाँ: फीचर्स को रैंक और चुनने के लिए सांख्यिकीय मापों का उपयोग करती हैं।
• रैपर विधियाँ: फीचर उपसमुच्चयों का मूल्यांकन करने के लिए मशीन लर्निंग मॉडलों का उपयोग करती हैं।
• एम्बेडेड विधियाँ: मॉडल प्रशिक्षण के दौरान फीचर चयन करती हैं।

फीचर निष्कर्षण

फीचर निष्कर्षण, जिसे फीचर प्रोजेक्शन भी कहा जाता है, नए फीचर्स बनाकर जो मूल फीचर्स के संयोजन होते हैं, डेटा को कम-आयामी स्पेस में रूपांतरित करता है। यह तरीका विशेष रूप से तब उपयोगी होता है जब मूल फीचर्स अत्यधिक सह-संबद्ध या अनावश्यक हों। 

लोकप्रिय फीचर निष्कर्षण विधियाँ शामिल हैं:

• PCA: डेटा को अधिकतम विचरण वाली दिशाओं पर प्रोजेक्ट करता है।
• LDA: कक्षा-अलगाव को अधिकतम करने पर केंद्रित।
• गैर-रेखीय विधियाँ: जब डेटा गैर-रेखीय मैनिफोल्ड पर स्थित हो तो t-SNE, UMAP, और ऑटोएन्कोडर जैसी तकनीकें उपयोग की जाती हैं।

इमेज डेटा के लिए आयाम-घटाव

इस गाइड में, हम सीखेंगे कि Python में आयाम-घटाव तकनीकों को कैसे लागू किया जाए। 

1. इमेज डेटासेट के साथ काम करना

हम आवश्यक Python पैकेज इंपोर्ट करके और sklearn.datasets से digits डेटासेट लोड करके शुरुआत करेंगे। 

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.manifold import TSNE
from sklearn.preprocessing import StandardScaler


# Load the digits dataset
digits = load_digits()
X = digits.data   # shape (1797, 64)
y = digits.target # labels for digits (0 through 9)

print("Data shape:", X.shape)
print("Labels shape:", y.shape)संचालित द्वारा

इस डेटासेट में 1,797 ग्रेस्केल छवियाँ हैं जो हस्तलिखित अंकों (0–9) की हैं। प्रत्येक को 8x8 इमेज (64 पिक्सेल) के रूप में दर्शाया गया है। डेटा को प्रत्येक इमेज के लिए 64-आयामी फीचर वेक्टर में फ्लैट किया गया है।

Data shape: (1797, 64)
Labels shape: (1797,)संचालित द्वारा

2. नमूना छवियों का विज़ुअलाइज़ेशन

हम अब डेटासेट से कुछ सैंपल विज़ुअलाइज़ करेंगे ताकि बेहतर समझ बने। Matplotlib का उपयोग करके, हम छवियों को उनकी मूल 8x8 ग्रिड फ़ॉर्मैट में पुनः आकार देकर प्रदर्शित करेंगे।

def plot_digits(images, labels, n_rows=2, n_cols=5):
    fig, axes = plt.subplots(n_rows, n_cols, figsize=(10, 4))
    axes = axes.ravel()
    for i in range(n_rows * n_cols):
        axes[i].imshow(images[i].reshape(8, 8), cmap='gray')
        axes[i].set_title(f"Label: {labels[i]}")
        axes[i].axis('off')
    plt.tight_layout()
    plt.show()

plot_digits(X, y)संचालित द्वारा

जैसा कि हम देख सकते हैं, यह छवियों की एक ग्रिड प्रदर्शित करता है, जो 0 से 9 तक के अंकों को ग्रेस्केल में दिखाती है। 

3. t-SNE लागू करना

t-SNE उच्च-आयामी डेटा को 2D या 3D में विज़ुअलाइज़ करने के लिए एक लोकप्रिय आयाम-घटाव तकनीक है। यह डेटा में स्थानीय संरचनाओं को सुरक्षित रखने में विशेष रूप से प्रभावी है।

ब्लॉग पढ़ें Introduction to t-SNE: Nonlinear Dimensionality Reduction and Data Visualization ताकि आप गैर-रेखीय आयाम-घटाव तकनीक का उपयोग करते हुए उच्च-आयामी डेटा को निम्न-आयामी स्पेस में विज़ुअलाइज़ करना सीखें।

t-SNE लागू करने से पहले, हम फीचर मानों को सामान्यीकृत करने के लिए StandardScaler का उपयोग करके डेटा को स्केल करते हैं।

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)संचालित द्वारा

इसके बाद, हम तेज़ गणना के लिए 500 नमूनों का एक उपसमुच्चय चुनते हैं और इस उपसमुच्चय पर t-SNE एल्गोरिथ्म चलाते हैं। 

यहाँ TSNE फ़ंक्शन के आर्ग्युमेंट्स उनके स्पष्टीकरण सहित दिए गए हैं: 

• n_components=2: यह निर्दिष्ट करता है कि डेटा को 2 विमाओं तक घटाया जाएगा।
• perplexity=30: Perplexity t-SNE में एक प्रमुख हाइपरपैरामीटर है, जो डेटा के स्थानीय और वैश्विक पहलुओं के बीच संतुलन नियंत्रित करता है..
• n_iter=1000: यह अनुकूलन के लिए इटरेशनों की संख्या सेट करता है। अधिक इटरेशनों से एल्गोरिदम बेहतर तरीके से अभिसरित होता है, लेकिन गणना समय भी बढ़ता है।
• random_state=42: पुनरुत्पादकता (reproducibility) के लिए उपयोग होता है। 

n_samples = 500
X_sub = X_scaled[:n_samples]
y_sub = y[:n_samples]

tsne = TSNE(n_components=2, 
            perplexity=30, 
            n_iter=1000, 
            random_state=42)
X_tsne = tsne.fit_transform(X_sub)

print("t-SNE result shape:", X_tsne.shape)संचालित द्वारा

आयामी घटाव सफल रहा, क्योंकि अब हमारे पास 500 नमूने हैं, जिनमें से प्रत्येक 2 विमाओं में दर्शाया गया है।

t-SNE result shape: (500, 2)संचालित द्वारा

4. t-SNE आउटपुट का दृश्यीकरण

अब हम 2D t-SNE डेटासेट को विज़ुअलाइज़ करते हैं। प्रत्येक बिंदु को उसके अंक लेबल के आधार पर रंगा गया है, जिससे यह देखने में मदद मिलती है कि t-SNE विभिन्न अंकों की कक्षाओं को कितना अच्छी तरह अलग करता है।

plt.figure(figsize=(8, 6))
scatter = plt.scatter(X_tsne[:, 0], X_tsne[:, 1], 
                      c=y_sub, cmap='jet', alpha=0.7)
plt.colorbar(scatter, label='Digit Label')
plt.title('t-SNE (2D) of Digits Dataset (500-sample)')
plt.show()संचालित द्वारा

t-SNE ने अंकों को 10 अलग-अलग समूहों में प्रभावी ढंग से विभाजित किया है, हालांकि कुछ समूहों के बीच ओवरलैप है।

5. t-SNE स्पेस में छवियों की तुलना

t-SNE स्पेस को और समझने के लिए, हम यादृच्छिक रूप से दो बिंदु चुनते हैं और 2D t-SNE स्पेस में उनके बीच यूक्लिडियन दूरी की गणना करते हैं। हम छवियों का विज़ुअलीकरण भी करेंगे ताकि देख सकें कि वे कितनी समान हैं।

import random

idx1, idx2 = random.sample(range(X_tsne.shape[0]), 2)

point1, point2 = X_tsne[idx1], X_tsne[idx2]
dist_tsne = np.linalg.norm(point1 - point2)

print(f"Comparing images #{idx1} and #{idx2}")
print(f"Distance in t-SNE space: {dist_tsne:.4f}")
print(f"Label of image #{idx1}: {y_sub[idx1]}")
print(f"Label of image #{idx2}: {y_sub[idx2]}")

# Plot the original images
fig, axes = plt.subplots(1, 2, figsize=(6, 3))
axes[0].imshow(X[idx1].reshape(8, 8), cmap='gray')
axes[0].set_title(f"Label: {y_sub[idx1]}")
axes[0].axis('off')

axes[1].imshow(X[idx2].reshape(8, 8), cmap='gray')
axes[1].set_title(f"Label: {y_sub[idx2]}")
axes[1].axis('off')

plt.show()संचालित द्वारा

t-SNE स्पेस में दूरी, 2D संकुचित निरूपण में दोनों छवियों के बीच असमानता को दर्शाती है।

Comparing images #291 and #90
Distance in t-SNE space: 35.7666
Label of image #291: 5
Label of image #90: 1
संचालित द्वारा

यदि आपको ऊपर दिया गया कोड चलाने में परेशानी हो रही है, तो कृपया अतिरिक्त सहायता के लिए DataLab वर्कस्पेस देखें।

निष्कर्ष

आयामी घटाव वास्तविक दुनिया के अनुप्रयोगों में एक महत्वपूर्ण भूमिका निभाता है—यह मशीन लर्निंग मॉडलों की दक्षता, सटीकता और व्याख्येयता में सुधार करता है, साथ ही जटिल डेटासेट्स के बेहतर दृश्यीकरण और विश्लेषण को सक्षम बनाता है। 

इस ट्यूटोरियल में, हमने आयामी घटाव की अवधारणा, उसका उद्देश्य, विधियाँ और प्रकार तलाशे। अंत में, हमने सीखा कि t-SNE तकनीक का उपयोग कर छवि डेटा को दृश्यीकरण और विश्लेषण के लिए कम-विमीय स्पेस में कैसे रूपांतरित किया जाए।

लें Dimensionality Reduction in Python कोर्स ताकि आप अपने डेटा में विमाओं को घटाने की अवधारणा समझें और Python में ऐसा करने की तकनीकों में महारत हासिल करें।