मशीन लर्निंग के बुनियादी सिद्धांतमध्यमपाठ 1165 मिनट का पाठ

Clustering: बिना लेबल के ग्रुप ढूंढना

k-means मिलते-जुलते rows के ग्रुप ढूंढता है जब किसी ने उन्हें लेबल न किया हो। जानें कि यह कैसे काम करता है, ग्रुप्स की संख्या कैसे चुनें, और ग्रुप्स को समझने के लिए इंसान की ज़रूरत क्यों पड़ती है।

✦ ट्यूटर से पूछें🧪 लैब · 20 min📝 पाठ का टेस्ट
पाठ वीडियो में

60 सेकंड में

Clustering: बिना लेबल के ग्रुप ढूंढना

k-means मिलते-जुलते rows के ग्रुप ढूंढता है जब किसी ने उन्हें लेबल न किया हो। जानें कि यह कैसे काम करता है, ग्रुप्स की संख्या कैसे चुनें, और ग्रुप्स को समझने के लिए इंसान की…

1/4
आसान शब्दों में
आप फर्श पर तरह-तरह के बटनों का एक बड़ा डिब्बा उलट देते हैं और बिना किसी के बताए उन्हें मिलते-जुलते बटनों के ढेरों में छांटते हैं। हो सकता है आप साइज़ के हिसाब से छांटें, या शायद रंग के हिसाब से। यही clustering है। कंप्यूटर मिलती-जुलती चीज़ों के ढेर बनाता है, और फिर आप तय करते हैं कि हर ढेर का क्या मतलब है।
Clustering में कोई लेबल नहीं होते। हमारे पास सिर्फ features होते हैं, और हम कंप्यूटर से ऐसे rows के ग्रुप ढूंढने को कहते हैं जो एक-दूसरे से मिलते-जुलते हों। यह unsupervised learning का एक प्रकार है।

k-means कैसे काम करता है

  1. 1

    k चुनें

    तय करें कि आपको कितने ग्रुप चाहिए, उदाहरण के लिए 3।
  2. 2

    शुरुआत करें

    k सेंटर पॉइंट्स रखें, अक्सर randomly चुने गए rows पर।
  3. 3

    असाइन करें

    हर row को उसके सबसे नज़दीकी सेंटर को सौंपें।
  4. 4

    मूव करें

    हर सेंटर को उससे जुड़े rows के औसत (average) पर खिसकाएं।
  5. 5

    दोहराएं

    असाइन करें और दोबारा खिसकाएं, जब तक कि सेंटर का हिलना-डुलना लगभग बंद न हो जाए।
क्योंकि शुरुआत रैंडम होती है, इसलिए अलग-अलग शुरुआतों से अलग-अलग ग्रुप बन सकते हैं। scikit-learn की n_init सेटिंग कई बार शुरुआत चलाती है और सबसे अच्छे नतीजे को रखती है। random_state सेट करने से वही नतीजे दोबारा मिलते हैं।
Python: grouping made-up shop customerspython
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

# Made-up customers of a small shop: visits per month, average spend (arbitrary units).
rng = np.random.default_rng(5)
a = rng.normal([2, 80], [1, 15], (40, 2))     # rare visits, bigger baskets
b = rng.normal([12, 25], [2, 8], (40, 2))     # frequent visits, small baskets
c = rng.normal([6, 50], [1.5, 10], (40, 2))   # in between
X = np.vstack([a, b, c])

km = KMeans(n_clusters=3, n_init=10, random_state=0).fit(X)
print("Centres (visits, spend):")
print(km.cluster_centers_.round(1))
print("Customers per group:", np.bincount(km.labels_))

plt.scatter(X[:, 0], X[:, 1], c=km.labels_)
plt.scatter(km.cluster_centers_[:, 0], km.cluster_centers_[:, 1], marker="x", s=200, color="red")
plt.xlabel("visits per month"); plt.ylabel("average spend")
मॉडल तीन ग्रुप ढूंढता है और हर एक को एक नंबर देता है: 0, 1 या 2। अपने आप में इन नंबरों का कोई मतलब नहीं होता। आप सेंटर्स को देखते हैं और तय करते हैं: "ग्रुप 1 छोटी टोकरियों के साथ अक्सर आता है, शायद आस-पास के परिवार।"

कितने ग्रुप? एल्बो मेथड

k-means inertia_ रिपोर्ट करता है: हर row से उसके सेंटर की कुल squared दूरी। ज़्यादा ग्रुप हमेशा इसे कम कर देते हैं, इसलिए सबसे कम वैल्यू हासिल करना ही मकसद नहीं होता। k = 1, 2, 3 वगैरह के लिए inertia का ग्राफ बनाएं। "एल्बो" (कोहनी जैसा मोड़) ढूंढें, जहाँ एक और ग्रुप जोड़ने से ज़्यादा फ़ायदा होना बंद हो जाता है। यह बस एक अंदाज़ा है, कोई पक्का नियम नहीं; सही k इस बात पर भी निर्भर करता है कि आपके काम के लिए क्या उपयोगी है।

ध्यान रखने वाली बातें

  • पहले स्केल करें। nearest neighbours की तरह ही k-means भी दूरियों का इस्तेमाल करता है। बड़े नंबरों वाला feature हावी हो जाएगा।
  • गोल, एक जैसे आकार के ग्रुप्स। k-means सबसे अच्छा तब काम करता है जब ग्रुप्स गोल-मटोल (blob-shaped) हों और उनका फैलाव एक जैसा हो। लंबे, मुड़े हुए या बहुत असमान ग्रुप्स के लिए दूसरे तरीकों की ज़रूरत होती है, जैसे DBSCAN।
  • यह हमेशा k ग्रुप ढूंढ ही लेता है। भले ही डेटा में असल में कोई ग्रुप न हो, फिर भी k-means उसे k ढेरों में बांट देगा। जांचें कि क्या उन ग्रुप्स का कोई मतलब निकल रहा है।
  • ग्रुप्स कोई परम सत्य नहीं होते। लोगों के ग्रुप्स को लेकर सावधान रहें। ग्राहकों के किसी क्लस्टर को "गरीब" या "जोखिम भरा" जैसा लेबल देना अनुचित और गलत हो सकता है। वही बताएं जो आंकड़े दिखाते हैं।
नोट
अगर जांचने के लिए आपके पास असली लेबल्स मौजूद हैं (जैसे कि iris डेटासेट में), तो आप उनके साथ क्लस्टर्स की तुलना कर सकते हैं। adjusted_rand_score एकदम सटीक मेल के लिए 1 और रैंडम ग्रुपिंग के लिए लगभग 0 देता है। असल clustering के कामों में आमतौर पर आपके पास लेबल्स नहीं होते, इसीलिए नतीजों को सही से समझना इतना ज़रूरी होता है।
यह करके देखें। कोड में, n_clusters=3 को बदलकर 5 करें। k-means इन अतिरिक्त ग्रुप्स के साथ क्या करता है?

और देखें और पढ़ें

scikit-learn: Clusteringscikit-learn · reading

लैब

स्केल किए गए iris मापनों पर k-means के लिए एक एल्बो टेबल, एक 3-ग्रुप मॉडल, और इस बात की जांच कि इसके ग्रुप्स असली प्रजातियों से कितने अच्छे से मेल खाते हैं।

~20 min

समस्या

मान लें कि आपको iris की प्रजातियों के बारे में नहीं पता है। आपके पास केवल चार नाप हैं।

  1. स्टार्टर चलाएं। यह features को X_scaled में स्केल करता है।
  2. 1 से 8 तक k के लिए, X_scaled पर KMeans(n_clusters=k, n_init=10, random_state=0) को फिट करें और इसके inertia_ को inertias[k] में स्टोर करें।
  3. 3 ग्रुप्स के साथ अंतिम kmeans को फिट करें (समान सेटिंग्स)।
  4. अब छिपे हुए प्रजाति लेबल्स का इस्तेमाल सिर्फ जांचने के लिए करें: ari को adjusted_rand_score(true_species, kmeans.labels_) पर सेट करें।
  5. टेबल और स्कोर प्रिंट करें। एल्बो कहाँ है? ग्रुप्स किन प्रजातियों को आपस में मिला देते हैं?

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

आपका काम तब पूरा होगा जब

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1ऐसा लगता है कि एल्बो 2 पर हो सकता है या 3 पर। ऐसा क्यों है, और बिना लेबल्स के आप कैसे फैसला करेंगे?दिखाएं

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

Q2आम तौर पर clustering के लिए adjusted Rand score को "सटीकता" का पैमाना कहना सही क्यों नहीं है?दिखाएं

ज़्यादातर असली clustering में कोई असली लेबल्स नहीं होते, और मिले हुए ग्रुप्स सार्थक हो सकते हैं भले ही वे किसी मौजूदा लेबल से मेल न खाते हों। यहाँ हमारे पास प्रजातियों के लेबल्स सिर्फ इसलिए हैं क्योंकि यह सिखाने के लिए बनाया गया डेटासेट है। यह स्कोर आपको यह बताता है कि क्लस्टर्स किसी एक खास ग्रुपिंग से कितने अच्छे से मेल खाते हैं, यह नहीं कि क्लस्टर्स "सही" हैं या नहीं।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

Clustering और classification में क्या अंतर है?

Classification लेबल वाले उदाहरणों से सीखता है और जाने-पहचाने ग्रुप्स का अनुमान लगाता है। Clustering में कोई लेबल नहीं होते और यह समानता के आधार पर नए ग्रुप बनाता है। हो सकता है कि उन ग्रुप्स का कोई मतलब निकले, या शायद न भी निकले।

क्या k-means टेक्स्ट कॉलम्स का इस्तेमाल कर सकता है?

सीधे तौर पर नहीं। k-means को ऐसे नंबरों की ज़रूरत होती है जहाँ दूरी का कोई मतलब निकलता हो। कैटेगरीज़ को सावधानी से नंबरों में बदलें, या फिर मिक्स्ड डेटा के लिए बने किसी तरीके का इस्तेमाल करें।

मुझे हर बार चलाने पर अलग नतीजा क्यों मिलता है?

क्योंकि रैंडम शुरुआत बदल जाती है। एक जैसे नतीजे पाने के लिए random_state सेट करें और n_init को 10 या उससे ज़्यादा रखें ताकि कई शुरुआतों में से सबसे बेहतरीन नतीजा चुना जा सके।

Clustering का इस्तेमाल और किसलिए किया जाता है?

मिलते-जुलते दस्तावेज़ों को एक ग्रुप में रखना, ऐसे असामान्य rows ढूंढना जो किसी ग्रुप में फिट न बैठें, किसी इमेज में रंगों को कंप्रेस करना, और सुपरवाइज़्ड मॉडल बनाने से पहले किसी नए डेटासेट को समझना।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें