पायथन और स्किकिट-लर्न के साथ पदानुक्रमित क्लस्टरिंग के लिए निश्चित गाइड

परिचय

इस गाइड में, हम इसे लागू करने पर ध्यान केंद्रित करेंगे स्किकिट-लर्न के साथ पदानुक्रमित क्लस्टरिंग एल्गोरिथम एक विपणन समस्या को हल करने के लिए।

गाइड पढ़ने के बाद, आप समझ जाएंगे:

• पदानुक्रमित क्लस्टरिंग कब लागू करें
• यह समझने के लिए कि क्या यह क्लस्टरिंग के लिए उपयुक्त है, डेटासेट की कल्पना कैसे करें
• डेटासेट के आधार पर सुविधाओं और नई सुविधाओं को पूर्व-प्रक्रिया कैसे करें
• पीसीए का उपयोग करके डेटासेट की आयामीता को कैसे कम करें
• समूहों को अलग करने के लिए डेंड्रोग्राम का उपयोग कैसे करें और पढ़ें
• डेंड्रोग्राम और क्लस्टरिंग एल्गोरिदम पर लागू होने वाली विभिन्न लिंकिंग विधियां और दूरी मीट्रिक क्या हैं
• समूहीकरण और विभाजनकारी क्लस्टरिंग रणनीतियाँ क्या हैं और वे कैसे काम करती हैं?
• स्किकिट-लर्न के साथ एग्लोमेरेटिव पदानुक्रमित क्लस्टरिंग को कैसे कार्यान्वित करें
• क्लस्टरिंग एल्गोरिदम से निपटने में सबसे आम समस्याएं क्या हैं और उन्हें कैसे हल किया जाए

अभिप्रेरण

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

क्या कोई ऐसा तरीका है जिससे आप यह निर्धारित करने में मदद कर सकते हैं कि कौन से ग्राहक समान हैं? उनमें से कितने एक ही समूह से संबंधित हैं? और कितने अलग-अलग समूह हैं?

उन प्रश्नों का उत्तर देने का एक तरीका है a . का उपयोग करना गुच्छन एल्गोरिथम, जैसे कि के-मीन्स, डीबीएससीएएन, पदानुक्रमित क्लस्टरिंग, आदि। सामान्य शब्दों में, क्लस्टरिंग एल्गोरिदम डेटा बिंदुओं के बीच समानताएं ढूंढते हैं और उन्हें समूहित करते हैं।

इस मामले में, हमारा मार्केटिंग डेटा काफी छोटा है। हमारे पास केवल 200 ग्राहकों की जानकारी है। मार्केटिंग टीम को ध्यान में रखते हुए, यह महत्वपूर्ण है कि हम उन्हें स्पष्ट रूप से समझा सकें कि क्लस्टर की संख्या के आधार पर निर्णय कैसे किए गए थे, इसलिए उन्हें यह समझाते हुए कि एल्गोरिदम वास्तव में कैसे काम करता है।

चूंकि हमारा डेटा छोटा है और व्याख्यात्मकता एक प्रमुख कारक है, हम लाभ उठा सकते हैं पदानुक्रमित क्लस्टरिंग इस समस्या के समाधान के लिये। इस प्रक्रिया को के रूप में भी जाना जाता है पदानुक्रमित क्लस्टरिंग विश्लेषण (एचसीए).

एचसीए के फायदों में से एक यह है कि यह व्याख्या योग्य है और छोटे डेटासेट पर अच्छा काम करता है।

इस परिदृश्य में ध्यान में रखने वाली एक और बात यह है कि एचसीए एक है के चलते किसी कलन विधि। डेटा को समूहीकृत करते समय, हमारे पास यह सत्यापित करने का कोई तरीका नहीं होगा कि हम सही ढंग से पहचान कर रहे हैं कि उपयोगकर्ता किसी विशिष्ट समूह से संबंधित है (हम समूहों को नहीं जानते हैं)। हमारे परिणामों की तुलना करने के लिए हमारे लिए कोई लेबल नहीं हैं। यदि हमने समूहों की सही पहचान की है, तो बाद में विपणन विभाग द्वारा दिन-प्रतिदिन के आधार पर इसकी पुष्टि की जाएगी (जैसा कि आरओआई, रूपांतरण दर, आदि जैसे मीट्रिक द्वारा मापा जाता है)।

अब जब हम उस समस्या को समझ गए हैं जिसे हम हल करने की कोशिश कर रहे हैं और इसे कैसे हल किया जाए, तो हम अपने डेटा पर एक नज़र डालना शुरू कर सकते हैं!

संक्षिप्त खोजपूर्ण डेटा विश्लेषण

डेटासेट डाउनलोड करने के बाद, ध्यान दें कि यह एक है सीएसवी (अल्पविराम से अलग किए गए मान) फ़ाइल कहा जाता है shopping-data.csv. डेटा को एक्सप्लोर करना और उसमें हेरफेर करना आसान बनाने के लिए, हम इसे a . में लोड करेंगे DataFrame पंडों का उपयोग करना:

import pandas as pd


path_to_file = 'home/projects/datasets/shopping-data.csv'
customer_data = pd.read_csv(path_to_file)

मार्केटिंग ने कहा कि उसने 200 ग्राहक रिकॉर्ड एकत्र किए हैं। हम जांच सकते हैं कि डाउनलोड किया गया डेटा 200 पंक्तियों के साथ पूरा हुआ है या नहीं shape विशेषता। यह हमें बताएगा कि हमारे पास क्रमशः कितनी पंक्तियाँ और स्तंभ हैं:

customer_data.shape

इसका परिणाम यह होगा:

(200, 5)

महान! हमारा डेटा 200 पंक्तियों के साथ पूरा हो गया है (ग्राहक रिकॉर्ड) और हमारे पास 5 कॉलम भी हैं (विशेषताएँ). यह देखने के लिए कि मार्केटिंग विभाग ने ग्राहकों से कौन-सी विशेषताएँ एकत्रित की हैं, हम कॉलम नामों को के साथ देख सकते हैं columns विशेषता। ऐसा करने के लिए, निष्पादित करें:

customer_data.columns

ऊपर दी गई स्क्रिप्ट लौटाती है:

Index(['CustomerID', 'Genre', 'Age', 'Annual Income (k$)',
       'Spending Score (1-100)'],
      dtype='object')

यहाँ, हम देखते हैं कि मार्केटिंग ने a . उत्पन्न किया है CustomerID, इकट्ठा किया Genre, Age, Annual Income (हजारों डॉलर में), और Spending Score 1 ग्राहकों में से प्रत्येक के लिए 100 से 200 तक जा रहा है। स्पष्टीकरण मांगे जाने पर उन्होंने कहा कि मूल्यों में Spending Score कॉलम दर्शाता है कि कोई व्यक्ति 1 से 100 के पैमाने पर कितनी बार मॉल में पैसा खर्च करता है। दूसरे शब्दों में, यदि किसी ग्राहक का स्कोर 0 है, तो यह व्यक्ति कभी भी पैसा खर्च नहीं करता है, और यदि स्कोर 100 है, तो हमने अभी देखा है सबसे ज्यादा खर्च करने वाला।

आइए हमारे डेटासेट में उपयोगकर्ताओं की खर्च करने की आदतों का निरीक्षण करने के लिए इस स्कोर के वितरण पर एक त्वरित नज़र डालें। वहीं पंडों hist() विधि मदद के लिए आती है:

customer_data['Spending Score (1-100)'].hist()

हिस्टोग्राम को देखने पर हम देखते हैं कि 35 से अधिक ग्राहकों के बीच के स्कोर हैं 40 और 60, तो 25 से कम के बीच स्कोर हैं 70 और 80. तो हमारे अधिकांश ग्राहक हैं संतुलित खर्च करने वाले, इसके बाद मध्यम से उच्च खर्च करने वाले। हम यह भी देख सकते हैं कि इसके बाद एक लाइन है 0, वितरण के बाईं ओर, और वितरण के दाईं ओर 100 से पहले दूसरी पंक्ति। इन रिक्त स्थानों का शायद यह अर्थ है कि वितरण में गैर-खर्च करने वाले लोग शामिल नहीं हैं, जिनका स्कोर . होगा 0, और यह कि . के स्कोर के साथ कोई उच्च व्ययकर्ता भी नहीं है 100.

यह सत्यापित करने के लिए कि क्या यह सत्य है, हम वितरण के न्यूनतम और अधिकतम मूल्यों को देख सकते हैं। उन मूल्यों को आसानी से वर्णनात्मक आंकड़ों के हिस्से के रूप में पाया जा सकता है, इसलिए हम इसका उपयोग कर सकते हैं describe() अन्य संख्यात्मक मान वितरण की समझ प्राप्त करने की विधि:

customer_data.describe().transpose()

यह हमें एक तालिका देगा जहां से हम अपने डेटासेट के अन्य मूल्यों के वितरण को पढ़ सकते हैं:

 						count 	mean 	std 		min 	25% 	50% 	75% 	max
CustomerID 				200.0 	100.50 	57.879185 	1.0 	50.75 	100.5 	150.25 	200.0
Age 					200.0 	38.85 	13.969007 	18.0 	28.75 	36.0 	49.00 	70.0
Annual Income (k$) 		200.0 	60.56 	26.264721 	15.0 	41.50 	61.5 	78.00 	137.0
Spending Score (1-100) 	200.0 	50.20 	25.823522 	1.0 	34.75 	50.0 	73.00 	99.0

हमारी परिकल्पना की पुष्टि होती है। min का मूल्य Spending Score is 1 और अधिकतम है 99. तो हमारे पास नहीं है 0 or 100 स्कोर खर्च करने वाले। आइए फिर ट्रांसपोज़्ड के अन्य स्तंभों पर एक नज़र डालें describe मेज़। जब देख रहे हैं mean और std कॉलम, हम देख सकते हैं कि for Age la mean is 38.85 और std लगभग 13.97. ऐसा ही होता है Annual Income, एक साथ mean of 60.56 और std 26.26के लिए, और Spending Score पंजीकरण शुल्क mean of 50 और std of 25.82. सभी सुविधाओं के लिए, mean मानक विचलन से दूर है, जो इंगित करता है हमारे डेटा में उच्च परिवर्तनशीलता है.

हमारा डेटा कैसे बदलता है, इसे बेहतर ढंग से समझने के लिए, आइए प्लॉट करें Annual Income वितरण:

customer_data['Annual Income (k$)'].hist()

जो हमें देगा:

हिस्टोग्राम में ध्यान दें कि हमारा अधिकांश डेटा, 35 से अधिक ग्राहक, संख्या के पास केंद्रित है 60, हमारे ऊपर mean, क्षैतिज अक्ष में। लेकिन जब हम बंटन के छोर की ओर बढ़ते हैं तो क्या होता है? बाईं ओर जाने पर, $60.560 माध्य से, अगला मूल्य जो हमें मिलेगा वह $34.300 है – माध्य ($60.560) से घटाकर मानक भिन्नता ($26.260)। यदि हम अपने डेटा वितरण के बाईं ओर और आगे जाते हैं तो एक समान नियम लागू होता है, हम मानक भिन्नता ($26.260) को वर्तमान मूल्य ($34.300) से घटाते हैं। इसलिए, हम $8.040 के मान का सामना करेंगे। ध्यान दें कि कैसे हमारा डेटा जल्दी से $60k से $8k तक चला गया। यह हर बार $26.260 "कूद" रहा है - बहुत भिन्न है, और यही कारण है कि हमारे पास इतनी उच्च परिवर्तनशीलता है।

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

अब तक, हमने अपने डेटा का आकार, उसके कुछ वितरण और वर्णनात्मक आँकड़े देखे हैं। पंडों के साथ, हम अपने डेटा प्रकारों को भी सूचीबद्ध कर सकते हैं और देख सकते हैं कि हमारी सभी 200 पंक्तियाँ भरी हुई हैं या उनमें से कुछ हैं null मान:

customer_data.info()

इसका परिणाम यह होगा:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 200 entries, 0 to 199
Data columns (total 5 columns):
 #   Column                  Non-Null Count  Dtype 
---  ------                  --------------  ----- 
 0   CustomerID              200 non-null    int64 
 1   Genre                   200 non-null    object
 2   Age                     200 non-null    int64 
 3   Annual Income (k$)      200 non-null    int64 
 4   Spending Score (1-100)  200 non-null    int64 
dtypes: int64(4), object(1)
memory usage: 7.9+ KB

यहाँ, हम देख सकते हैं कि वहाँ नहीं हैं null डेटा में मान और हमारे पास केवल एक श्रेणीबद्ध कॉलम है - Genre. इस स्तर पर, यह महत्वपूर्ण है कि हम इस बात को ध्यान में रखें कि क्लस्टरिंग मॉडल में कौन सी विशेषताएँ जोड़ी जाने के लिए दिलचस्प लगती हैं। यदि हम अपने मॉडल में Genre कॉलम जोड़ना चाहते हैं, तो हमें इसके मूल्यों को बदलने की आवश्यकता होगी स्पष्ट सेवा मेरे संख्यात्मक.

आइए देखें कैसे Genre हमारे डेटा के पहले 5 मूल्यों पर एक त्वरित नज़र डालने से भरा जाता है:

customer_data.head() 

इसका परिणाम यह होगा:

    CustomerID 	Genre 	Age 	Annual Income (k$) 	Spending Score (1-100)
0 	1 			Male 	19 		15 					39
1 	2 			Male 	21 		15 					81
2 	3 			Female 	20 		16 					6
3 	4 			Female 	23 		16 					77
4 	5 			Female 	31 		17 					40

ऐसा लगता है कि इसमें केवल Female और Male श्रेणियाँ। हम इसके अनूठे मूल्यों पर एक नज़र डालकर इसके बारे में सुनिश्चित हो सकते हैं unique:

customer_data['Genre'].unique()

यह हमारी धारणा की पुष्टि करता है:

array(['Male', 'Female'], dtype=object)

अब तक, हम जानते हैं कि हमारे पास केवल दो शैलियाँ हैं, यदि हम अपने मॉडल पर इस सुविधा का उपयोग करने की योजना बनाते हैं, Male में तब्दील किया जा सकता है 0 और Female सेवा मेरे 1. शैलियों के बीच अनुपात की जांच करना भी महत्वपूर्ण है, यह देखने के लिए कि क्या वे संतुलित हैं। हम इसे के साथ कर सकते हैं value_counts() विधि और उसका तर्क normalize=True के बीच प्रतिशत दिखाने के लिए Male और Female:

customer_data['Genre'].value_counts(normalize=True)

यह आउटपुट:

Female    0.56
Male      0.44
Name: Genre, dtype: float64

डेटासेट में हमारे पास 56% महिलाएं और 44% पुरुष हैं। उनके बीच का अंतर केवल 16% है, और हमारा डेटा 50/50 नहीं बल्कि है पर्याप्त संतुलित जिससे कोई परेशानी न हो। यदि परिणाम 70/30, 60/40 थे, तो उस अनुपात को अधिक संतुलित बनाने के लिए या तो अधिक डेटा एकत्र करने या किसी प्रकार की डेटा वृद्धि तकनीक को नियोजित करने की आवश्यकता हो सकती है।

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

इस बात पर अनुमान लगाने के बाद कि दोनों के साथ क्या किया जा सकता है - या श्रेणीबद्ध होना - Genre और Age कॉलम, जो चर्चा की गई है उसे लागू करें।

एन्कोडिंग चर और फ़ीचर इंजीनियरिंग

आइए को विभाजित करके शुरू करें Age समूहों में जो 10 में भिन्न होते हैं, ताकि हमारे पास 20-30, 30-40, 40-50, इत्यादि हों। चूंकि हमारा सबसे छोटा ग्राहक 15 साल का है, इसलिए हम 15 से शुरू कर सकते हैं और 70 पर खत्म हो सकते हैं, जो डेटा में सबसे पुराने ग्राहक की उम्र है। 15 से शुरू होकर 70 पर समाप्त होने पर, हमारे पास 15-20, 20-30, 30-40, 40-50, 50-60, और 60-70 अंतराल होंगे।

समूह के लिए या बिन Age इन अंतरालों में मान, हम पंडों का उपयोग कर सकते हैं cut() उन्हें डिब्बे में काटने की विधि और फिर डिब्बे को एक नया असाइन करें Age Groups स्तंभ:

intervals = [15, 20, 30, 40, 50, 60, 70]
col = customer_data['Age']
customer_data['Age Groups'] = pd.cut(x=col, bins=intervals)


customer_data['Age Groups'] 

इसका परिणाम यह होगा:

0      (15, 20]
1      (20, 30]
2      (15, 20]
3      (20, 30]
4      (30, 40]
         ...   
195    (30, 40]
196    (40, 50]
197    (30, 40]
198    (30, 40]
199    (20, 30]
Name: Age Groups, Length: 200, dtype: category
Categories (6, interval[int64, right]): [(15, 20] < (20, 30] < (30, 40] < (40, 50] < (50, 60] < (60, 70]]

ध्यान दें कि कॉलम मानों को देखते समय, एक पंक्ति भी होती है जो निर्दिष्ट करती है कि हमारे पास 6 श्रेणियां हैं और सभी बिन्ड डेटा अंतराल प्रदर्शित करती हैं। इस तरह, हमने अपने पहले के संख्यात्मक डेटा को वर्गीकृत किया है और एक नया बनाया है Age Groups सुविधा.

और प्रत्येक श्रेणी में हमारे पास कितने ग्राहक हैं? हम जल्दी से यह जान सकते हैं कि कॉलम को समूहीकृत करके और मानों को के साथ गिनकर groupby() और count():

customer_data.groupby('Age Groups')['Age Groups'].count()

इसका परिणाम यह होगा:

Age Groups
(15, 20]    17
(20, 30]    45
(30, 40]    60
(40, 50]    38
(50, 60]    23
(60, 70]    17
Name: Age Groups, dtype: int64

यह पता लगाना आसान है कि अधिकांश ग्राहक 30 से 40 वर्ष के बीच हैं, उसके बाद ग्राहक 20 से 30 के बीच हैं और फिर ग्राहक 40 से 50 के बीच हैं। यह विपणन विभाग के लिए भी अच्छी जानकारी है।

फिलहाल, हमारे पास दो श्रेणीगत चर हैं, Age और Genre, जिसे हमें अपने मॉडल में उपयोग करने में सक्षम होने के लिए संख्याओं में बदलना होगा। उस परिवर्तन को करने के कई अलग-अलग तरीके हैं - हम पंडों का उपयोग करेंगे get_dummies() विधि जो प्रत्येक अंतराल और शैली के लिए एक नया कॉलम बनाती है और फिर उसके मानों को 0s और 1s से भरती है- इस तरह के ऑपरेशन को कहा जाता है एक-गर्म एन्कोडिंग. आइए देखें कि यह कैसा दिखता है:

customer_data_oh = pd.get_dummies(customer_data)

customer_data_oh 

यह हमें परिणामी तालिका का पूर्वावलोकन देगा:

आउटपुट के साथ, यह देखना आसान है कि कॉलम Genre स्तंभों में विभाजित किया गया था - Genre_Female और Genre_Male. जब ग्राहक महिला हो, Genre_Female के बराबर है 1, और जब ग्राहक पुरुष होता है, तो यह बराबर होता है 0.

यह भी Age Groups कॉलम को 6 कॉलम में विभाजित किया गया था, प्रत्येक अंतराल के लिए एक, जैसे कि Age Groups_(15, 20], Age Groups_(20, 30], और इसी तरह। उसी तरीके से Genre, जब ग्राहक 18 वर्ष का हो, तो Age Groups_(15, 20] मूल्य है 1 और अन्य सभी कॉलम का मान है 0.

RSI लाभ एक-हॉट एन्कोडिंग कॉलम मानों का प्रतिनिधित्व करने में सरलता है, यह समझना आसान है कि क्या हो रहा है - जबकि हानि यह है कि हमने पहले से मौजूद कॉलम के साथ योग करने के लिए अब 8 अतिरिक्त कॉलम बनाए हैं।

वन-हॉट एन्कोडिंग हमारे डेटा में 0s भी जोड़ता है, जिससे यह अधिक विरल हो जाता है, जो कुछ एल्गोरिदम के लिए एक समस्या हो सकती है जो डेटा विरलता के प्रति संवेदनशील होते हैं।

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

मूल प्लॉटिंग और आयामी कमी

हमारे डेटासेट में 11 कॉलम हैं, और कुछ ऐसे तरीके हैं जिनसे हम उस डेटा की कल्पना कर सकते हैं। पहला इसे 10-आयामों (उसके साथ शुभकामनाएँ) में प्लॉट करके है। दस क्योंकि Customer_ID कॉलम पर विचार नहीं किया जा रहा है। दूसरा है हमारी प्रारंभिक संख्यात्मक विशेषताओं को प्लॉट करना, और तीसरा है हमारी 10 विशेषताओं को 2 में बदलना - इसलिए, एक आयामी कमी का प्रदर्शन करना।

डेटा की प्रत्येक जोड़ी को प्लॉट करना

चूंकि 10 आयामों को प्लॉट करना थोड़ा असंभव है, हम दूसरे दृष्टिकोण के साथ जाने का विकल्प चुनेंगे - हम अपनी प्रारंभिक विशेषताओं को प्लॉट करेंगे। हम अपने क्लस्टरिंग विश्लेषण के लिए उनमें से दो को चुन सकते हैं। एक तरह से हम देख सकते हैं कि हमारे सभी डेटा जोड़े एक सीबोर्न के साथ संयुक्त हैं pairplot():

import seaborn as sns


customer_data = customer_data.drop('CustomerID', axis=1)

sns.pairplot(customer_data)

कौन सा प्रदर्शित करता है:

एक नज़र में, हम उन स्कैटरप्लॉट्स को देख सकते हैं जिनमें डेटा के समूह प्रतीत होते हैं। जो दिलचस्प लगता है वह स्कैटरप्लॉट है जो जोड़ता है Annual Income और Spending Score. ध्यान दें कि अन्य चर स्कैटरप्लॉट के बीच कोई स्पष्ट अलगाव नहीं है। अधिक से अधिक, हम शायद यह बता सकते हैं कि में बिंदुओं के दो अलग-अलग संकेंद्रण हैं Spending Score vs Age स्कैटर प्लॉट।

दोनों स्कैटरप्लॉट से मिलकर बनता है Annual Income और Spending Score मूलतः समान हैं। हम इसे दो बार देख सकते हैं क्योंकि x और y-अक्ष का आदान-प्रदान किया गया था। उनमें से किसी एक पर एक नज़र डालने पर, हम देख सकते हैं कि पाँच अलग-अलग समूह क्या हैं। आइए सीबोर्न के साथ केवल उन दो विशेषताओं की साजिश करें scatterplot() करीब से देखने के लिए:

sns.scatterplot(x=customer_data['Annual Income (k$)'],
                y=customer_data['Spending Score (1-100)'])

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

एक दम बढ़िया! अब तक, हमारे पास अपना मॉडल बनाने के लिए पहले से ही दो चर हैं। यह जो दर्शाता है उसके अलावा, यह मॉडल को सरल, पारिश्रमिक और अधिक व्याख्या योग्य भी बनाता है।

पीसीए का उपयोग करने के बाद डेटा प्लॉट करना

ऐसा लगता है कि हमारा दूसरा दृष्टिकोण शायद सबसे अच्छा है, लेकिन आइए हमारे तीसरे दृष्टिकोण पर भी एक नज़र डालें। यह तब उपयोगी हो सकता है जब हम डेटा को प्लॉट नहीं कर सकते क्योंकि इसमें बहुत अधिक आयाम हैं, या जब कोई डेटा सांद्रता या समूहों में स्पष्ट अलगाव नहीं है। जब वे स्थितियां होती हैं, तो यह अनुशंसा की जाती है कि डेटा आयामों को कम करने का प्रयास करें जिसे कहा जाता है प्रधान घटक विश्लेषण (पीसीए).

पीसीए जितना संभव हो सके इसकी अधिक से अधिक जानकारी को संरक्षित करने का प्रयास करते हुए हमारे डेटा के आयामों को कम करेगा। आइए पहले एक विचार प्राप्त करें कि पीसीए कैसे काम करता है, और फिर हम यह चुन सकते हैं कि हम अपने डेटा को कितने डेटा आयामों तक कम करेंगे।

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

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

सबसे अच्छी लाइन (रैखिक संयोजन) के साथ, पीसीए को अपने अक्षों की दिशा मिलती है, जिसे कहा जाता है egenvectors, और इसके रैखिक गुणांक, eigenvalues. eigenvectors और eigenvalues ​​​​का संयोजन - या कुल्हाड़ियों की दिशा और गुणांक - हैं मूल घटक पीसीए की। और वह तब होता है जब हम प्रत्येक विशेषता के स्पष्ट विचरण के आधार पर अपने आयामों की संख्या चुन सकते हैं, यह समझकर कि हम किन प्रमुख घटकों को रखना चाहते हैं या वे कितने विचरण के आधार पर त्यागना चाहते हैं।

मुख्य घटकों को प्राप्त करने के बाद, पीसीए eigenvectors का उपयोग सुविधाओं का एक वेक्टर बनाने के लिए करता है जो डेटा को मूल अक्ष से प्रमुख घटकों द्वारा दर्शाए गए डेटा को पुन: उन्मुख करता है - इस तरह डेटा आयाम कम हो जाते हैं।

पीसीए लागू करने से पहले, हमें इनमें से चुनना होगा Age स्तंभ या Age Groups हमारे पहले के एक-हॉट एन्कोडेड डेटा में कॉलम। चूंकि दोनों कॉलम एक ही जानकारी का प्रतिनिधित्व करते हैं, इसलिए इसे दो बार पेश करने से हमारे डेटा भिन्नता प्रभावित होती है। अगर Age Groups कॉलम चुना गया है, बस हटा दें Age पंडों का उपयोग करते हुए स्तंभ drop() विधि और इसे पुन: असाइन करें customer_data_oh चर:

customer_data_oh = customer_data_oh.drop(['Age'], axis=1)
customer_data_oh.shape 

अब हमारे डेटा में 10 कॉलम हैं, जिसका अर्थ है कि हम कॉलम द्वारा एक प्रमुख घटक प्राप्त कर सकते हैं और यह चुन सकते हैं कि हम उनमें से कितने का उपयोग यह मापकर करेंगे कि एक नया आयाम कितना हमारे डेटा भिन्नता को बताता है।

आइए इसे स्किकिट-लर्न के साथ करें PCA. हम प्रत्येक आयाम के व्याख्या किए गए विचरण की गणना करेंगे, जो द्वारा दिया गया है explained_variance_ratio_ , और उसके बाद उनके संचयी योग को देखें cumsum() :

from sklearn.decomposition import PCA

pca = PCA(n_components=10)
pca.fit_transform(customer_data_oh)
pca.explained_variance_ratio_.cumsum()

हमारे संचयी व्याख्या किए गए संस्करण हैं:

array([0.509337  , 0.99909504, 0.99946364, 0.99965506, 0.99977937,
       0.99986848, 0.99993716, 1.        , 1.        , 1.        ])

हम देख सकते हैं कि पहला आयाम 50% डेटा की व्याख्या करता है, और जब दूसरे आयाम के साथ जोड़ा जाता है, तो वे 99% प्रतिशत की व्याख्या करते हैं। इसका मतलब है कि पहले 2 आयाम पहले से ही हमारे 99% डेटा की व्याख्या करते हैं। तो हम 2 घटकों के साथ एक पीसीए लागू कर सकते हैं, हमारे प्रमुख घटक प्राप्त कर सकते हैं और उन्हें प्लॉट कर सकते हैं:

from sklearn.decomposition import PCA

pca = PCA(n_components=2)
pcs = pca.fit_transform(customer_data_oh)

pc1_values = pcs[:,0]
pc2_values = pcs[:,1]
sns.scatterplot(x=pc1_values, y=pc2_values)

पीसीए के बाद डेटा प्लॉट उस प्लॉट के समान है जो पीसीए के बिना डेटा के केवल दो कॉलम का उपयोग कर रहा है। ध्यान दें कि समूह बनाने वाले बिंदु पहले की तुलना में पीसीए के बाद करीब और थोड़ा अधिक केंद्रित हैं।

डेंड्रोग्राम के साथ पदानुक्रमित संरचना की कल्पना करना

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

RSI डेंड्रोग्राम डेटासेट में बिंदुओं को जोड़ने का परिणाम है। यह पदानुक्रमित क्लस्टरिंग प्रक्रिया का एक दृश्य प्रतिनिधित्व है। और पदानुक्रमित क्लस्टरिंग प्रक्रिया कैसे काम करती है? खैर... यह निर्भर करता है - शायद एक उत्तर जो आपने डेटा साइंस में पहले ही बहुत कुछ सुना है।

पदानुक्रमित क्लस्टरिंग को समझना

जब पदानुक्रमित क्लस्टरिंग एल्गोरिथम (HCA) बिंदुओं को जोड़ने और समूहों को खोजने के लिए शुरू होता है, यह पहले 2 बड़े समूहों में बिंदुओं को विभाजित कर सकता है, और फिर उन दो समूहों में से प्रत्येक को छोटे 2 समूहों में विभाजित कर सकता है, जिसमें कुल 4 समूह होते हैं, जो कि है बांटनेवाला और ऊपर से नीचे दृष्टिकोण.

वैकल्पिक रूप से, यह विपरीत कर सकता है - यह सभी डेटा बिंदुओं को देख सकता है, 2 बिंदुओं को ढूंढ सकता है जो एक दूसरे के करीब हैं, उन्हें लिंक कर सकते हैं, और फिर उन अन्य बिंदुओं को ढूंढ सकते हैं जो उन लिंक किए गए बिंदुओं के निकटतम हैं और 2 समूहों का निर्माण जारी रखते हैं। से नीचे से ऊपर. वह कौन सा है ढेर दृष्टिकोण हम विकसित करेंगे।

एग्लोमेरेटिव पदानुक्रमित क्लस्टरिंग करने के लिए कदम

सामूहिक दृष्टिकोण को और भी स्पष्ट करने के लिए, निम्नलिखित के चरण हैं: एग्लोमेरेटिव पदानुक्रमित क्लस्टरिंग (एएचसी) कलन विधि:

1. प्रारंभ में, प्रत्येक डेटा बिंदु को एक क्लस्टर के रूप में मानें। इसलिए, प्रारंभ में समूहों की संख्या K होगी - जबकि K एक पूर्णांक है जो डेटा बिंदुओं की संख्या का प्रतिनिधित्व करता है।
2. K-1 क्लस्टर में परिणामित दो निकटतम डेटा बिंदुओं को जोड़कर एक क्लस्टर बनाएं।
3. दो निकटतम समूहों में शामिल होकर अधिक क्लस्टर बनाएं जिसके परिणामस्वरूप K-2 क्लस्टर हों।
4. उपरोक्त तीन चरणों को तब तक दोहराएं जब तक कि एक बड़ा क्लस्टर न बन जाए।

यदि आप ACH एल्गोरिथम के चरणों को 4 से 1 तक उल्टा करते हैं - तो वे चरण होंगे *विभाजनकारी पदानुक्रमित क्लस्टरिंग (डीएचसी)*.

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

आइए डेटा के पदानुक्रमित संबंधों की कल्पना करने के लिए हमारे ग्राहक डेटा डेंड्रोग्राम को प्लॉट करें। इस बार, हम उपयोग करेंगे scipy हमारे डेटासेट के लिए डेंड्रोग्राम बनाने के लिए लाइब्रेरी:

import scipy.cluster.hierarchy as shc
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 7))
plt.title("Customers Dendrogram")


selected_data = customer_data_oh.iloc[:, 1:3]
clusters = shc.linkage(selected_data, 
            method='ward', 
            metric="euclidean")
shc.dendrogram(Z=clusters)
plt.show()

स्क्रिप्ट का आउटपुट इस तरह दिखता है:

ऊपर की स्क्रिप्ट में, हमने अपने पॉइंट्स के साथ क्लस्टर्स और सबक्लस्टर्स जेनरेट किए हैं, परिभाषित किया है कि हमारे पॉइंट्स कैसे लिंक होंगे (इसे लागू करके) ward विधि), और बिंदुओं के बीच की दूरी को कैसे मापें ( . का उपयोग करके) euclidean मीट्रिक)।

डेंड्रोग्राम की साजिश के साथ, डीएचसी और एएचसी की वर्णित प्रक्रियाओं की कल्पना की जा सकती है। टॉप-डाउन दृष्टिकोण की कल्पना करने के लिए डेंड्रोग्राम के ऊपर से शुरू करें और नीचे जाएं, और इसके विपरीत करें, नीचे से शुरू करें और बॉटम-अप दृष्टिकोण की कल्पना करने के लिए ऊपर की ओर बढ़ें।

लिंकेज के तरीके

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

लिंकेज के कुछ तरीके हैं:

• सिंगल लिंकेज: के रूप में भी जाना जाता है निकटतम पड़ोसी (एनएन). समूहों के बीच की दूरी को उनके निकटतम सदस्यों के बीच की दूरी से परिभाषित किया जाता है।

• पूर्ण जुड़ाव: के रूप में भी जाना जाता है सबसे दूर का पड़ोसी (FN), सबसे दूर बिंदु एल्गोरिदमया, वूर हीस एल्गोरिथम. समूहों के बीच की दूरी को उनके सबसे दूर के सदस्यों के बीच की दूरी से परिभाषित किया जाता है। यह विधि कम्प्यूटेशनल रूप से महंगी है।

• औसत जुड़ाव: के रूप में भी जाना जाता है यूपीजीएमए (अंकगणित माध्य के साथ भार रहित जोड़ी समूह विधि). प्रत्येक क्लस्टर के अंकों की संख्या के प्रतिशत की गणना दो समूहों के अंकों की संख्या के संबंध में की जाती है यदि वे विलय हो गए थे।

• भारित संबंध: के रूप में भी जाना जाता है डब्ल्यूपीजीएमए (अंकगणित माध्य के साथ भारित जोड़ी समूह विधि). दो समूहों के अलग-अलग बिंदु छोटे और बड़े क्लस्टर के बीच की कुल दूरी में योगदान करते हैं।
• केन्द्रक संबंध: के रूप में भी जाना जाता है यूपीजीएमसी (सेंट्रोइड्स का उपयोग करके भारित जोड़ी समूह विधि). सभी बिंदुओं (सेंट्रोइड) के माध्य द्वारा परिभाषित एक बिंदु की गणना प्रत्येक क्लस्टर के लिए की जाती है और समूहों के बीच की दूरी उनके संबंधित सेंट्रोइड्स के बीच की दूरी होती है।

• वार्ड लिंकेज: के रूप में भी जाना जाता है मिसक्यू (वर्गों के योग की न्यूनतम वृद्धि). यह दो समूहों के बीच की दूरी को निर्दिष्ट करता है, वर्ग त्रुटि (ईएसएस) के योग की गणना करता है, और क्रमिक रूप से छोटे ईएसएस के आधार पर अगले समूहों को चुनता है। वार्ड की विधि प्रत्येक चरण में ईएसएस की वृद्धि को कम करने का प्रयास करती है। इसलिए, त्रुटि को कम करना।

दूरी मेट्रिक्स

लिंकेज के अलावा, हम कुछ सबसे अधिक उपयोग की जाने वाली दूरी मेट्रिक्स भी निर्दिष्ट कर सकते हैं:

• इयूक्लिडियन: के रूप में भी जाना जाता है पाइथागोरस या सीधी रेखा दूरी। यह अंतरिक्ष में दो बिंदुओं के बीच की दूरी की गणना उनके बीच से गुजरने वाले रेखा खंड की लंबाई को मापकर करता है। यह पाइथागोरस प्रमेय का उपयोग करता है और दूरी मान परिणाम है (ग) समीकरण का:

$$
सी^2 = ए^2 + बी^2
$$

• मैनहट्टन: यह भी कहा जाता है सिटी-ब्लॉक, टैक्सीकैब दूरी। यह दो बिंदुओं के सभी आयामों में मापों के बीच पूर्ण अंतर का योग है। यदि वे आयाम दो हैं, तो यह एक ब्लॉक चलने पर दाएं और फिर बाएं बनाने के समान है।

• मिंकोवस्की: यह यूक्लिडियन और मैनहट्टन दोनों दूरियों का सामान्यीकरण है। यह मिंकोव्स्की मीट्रिक . के क्रम में पूर्ण अंतर के आधार पर दूरियों की गणना करने का एक तरीका है p. हालांकि यह किसी के लिए परिभाषित किया गया है p> 0, यह शायद ही कभी 1, 2, और ∞ (अनंत) के अलावा अन्य मानों के लिए उपयोग किया जाता है। मिंकोव्स्की दूरी मैनहट्टन दूरी के समान होती है जब p = 1, और यूक्लिडियन दूरी के समान जब p = 2.

$$
बायाँ(X,Yright) = बायाँ(sum_{i=1}^n |x_i-y_i|^pright)^{frac{1}{p}}
$$

• Chebyshev: के रूप में भी जाना जाता है बिसात दूरी। यह मिंकोव्स्की दूरी का चरम मामला है। जब हम पैरामीटर के मान के रूप में अनंत का उपयोग करते हैं पी (पी = ), हम एक मीट्रिक के साथ समाप्त होते हैं जो दूरी को निर्देशांक के बीच अधिकतम पूर्ण अंतर के रूप में परिभाषित करता है।
• कोसाइन: यह बिंदुओं के दो अनुक्रमों या सदिशों के बीच कोणीय कोज्या दूरी है। कोसाइन समानता उनकी लंबाई के उत्पाद द्वारा विभाजित वैक्टर का डॉट उत्पाद है।
• जैककार्ड: बिंदुओं के परिमित सेट के बीच समानता को मापता है। इसे प्रत्येक सेट (चौराहे) में सामान्य बिंदुओं में अंकों की कुल संख्या (कार्डिनैलिटी) के रूप में परिभाषित किया जाता है, जो दोनों सेटों (संघ) के कुल बिंदुओं के कुल अंकों (कार्डिनैलिटी) से विभाजित होता है।
• जेन्सेन-शैनन: कुलबैक-लीब्लर विचलन पर आधारित। यह अंक की संभाव्यता वितरण पर विचार करता है और उन वितरणों के बीच समानता को मापता है। यह संभाव्यता सिद्धांत और सांख्यिकी का एक लोकप्रिय तरीका है।

हमने चुना है परवरिश और इयूक्लिडियन डेंड्रोग्राम के लिए क्योंकि वे सबसे अधिक इस्तेमाल की जाने वाली विधि और मीट्रिक हैं। वे आमतौर पर अच्छे परिणाम देते हैं क्योंकि वार्ड लिंक त्रुटियों को कम करने के आधार पर इंगित करता है, और यूक्लिडियन निचले आयामों में अच्छी तरह से काम करता है।

इस उदाहरण में, हम मार्केटिंग डेटा की दो विशेषताओं (कॉलम) और 200 टिप्पणियों या पंक्तियों के साथ काम कर रहे हैं। चूँकि प्रेक्षणों की संख्या सुविधाओं की संख्या (200 > 2) से अधिक है, इसलिए हम निम्न-आयामी स्थान में काम कर रहे हैं।

जब सुविधाओं की संख्या (च) अवलोकनों की संख्या से बड़ा है (एन) - ज्यादातर के रूप में लिखा च >> नहीं, इसका मतलब है कि हमारे पास एक है उच्च आयामी स्थान.

यदि हम अधिक विशेषताओं को शामिल करते हैं, तो हमारे पास 200 से अधिक विशेषताएं हैं, यूक्लिडियन दूरी बहुत अच्छी तरह से काम नहीं कर सकती है, क्योंकि इससे बहुत बड़ी जगह में सभी छोटी दूरी को मापने में कठिनाई होगी जो केवल बड़ी हो जाती है। दूसरे शब्दों में, यूक्लिडियन दूरी दृष्टिकोण में डेटा के साथ काम करने में कठिनाइयाँ होती हैं विरलता. यह एक ऐसा मुद्दा है जिसे कहा जाता है आयामीता का अभिशाप. दूरी के मान इतने छोटे हो जाते हैं, जैसे कि वे बड़े स्थान पर "पतला" हो जाते हैं, विकृत हो जाते हैं जब तक कि वे 0 नहीं हो जाते।

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

एक डेंड्रोग्राम में समूहों की एक दिलचस्प संख्या ढूँढना सबसे बड़ा क्षैतिज स्थान खोजने के समान है जिसमें कोई लंबवत रेखाएं नहीं होती हैं (सबसे लंबी लंबवत रेखाओं वाला स्थान)। इसका मतलब है कि समूहों के बीच अधिक अलगाव है।

हम एक क्षैतिज रेखा खींच सकते हैं जो उस सबसे लंबी दूरी से होकर गुजरती है:

plt.figure(figsize=(10, 7))
plt.title("Customers Dendogram with line")
clusters = shc.linkage(selected_data, 
            method='ward', 
            metric="euclidean")
shc.dendrogram(clusters)
plt.axhline(y = 125, color = 'r', linestyle = '-')

क्षैतिज रेखा का पता लगाने के बाद, हम गिनते हैं कि कितनी बार हमारी ऊर्ध्वाधर रेखाएँ इससे पार हुईं - इस उदाहरण में, 5 बार। तो 5 उन समूहों की संख्या का एक अच्छा संकेत प्रतीत होता है जिनके बीच सबसे अधिक दूरी है।

एक समूहबद्ध पदानुक्रमित क्लस्टरिंग लागू करना

मूल डेटा का उपयोग करना

अब तक हमने अपने डेटासेट के लिए सुझाए गए क्लस्टरों की संख्या की गणना की है जो हमारे प्रारंभिक विश्लेषण और हमारे पीसीए विश्लेषण के साथ पुष्टि करते हैं। अब हम स्किकिट-लर्न . का उपयोग करके अपना एग्लोमेरेटिव पदानुक्रमित क्लस्टरिंग मॉडल बना सकते हैं AgglomerativeClustering और विपणन बिंदुओं के लेबल का पता लगाएं labels_:

from sklearn.cluster import AgglomerativeClustering

clustering_model = AgglomerativeClustering(n_clusters=5, affinity='euclidean', linkage='ward')
clustering_model.fit(selected_data)
clustering_model.labels_

इसका परिणाम यह होगा:

array([4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3,
       4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 1,
       4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 0, 2, 0, 2,
       1, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 2, 1, 2, 0, 2, 0, 2, 0, 2,
       0, 2, 0, 2, 0, 2, 1, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2,
       0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2,
       0, 2])

हमने इस बिंदु तक पहुंचने के लिए बहुत जांच की है। और इन लेबलों का क्या अर्थ है? यहां, हमारे पास हमारे डेटा के प्रत्येक बिंदु को 0 से 4 के समूह के रूप में लेबल किया गया है:

data_labels = clustering_model.labels_
sns.scatterplot(x='Annual Income (k$)', 
                y='Spending Score (1-100)', 
                data=selected_data, 
                hue=data_labels,
                pallete="rainbow").set_title('Labeled Customer Data')

यह हमारा अंतिम क्लस्टर डेटा है। आप रंग-कोडित डेटा बिंदुओं को पाँच समूहों के रूप में देख सकते हैं।

डेटा नीचे दाईं ओर इंगित करता है (लेबल: 0, पर्पल डेटा पॉइंट) उच्च वेतन लेकिन कम खर्च वाले ग्राहकों के हैं। ये ऐसे ग्राहक हैं जो अपना पैसा सावधानी से खर्च करते हैं।

इसी तरह, ऊपर दाईं ओर ग्राहक (लेबल: 2, ग्रीन डेटा पॉइंट), उच्च वेतन और उच्च खर्च वाले ग्राहक हैं। ये उस प्रकार के ग्राहक हैं जिन्हें कंपनियां लक्षित करती हैं।

बीच में ग्राहक (लेबल: 1, ब्लू डेटा पॉइंट) औसत आय और औसत खर्च वाले हैं। सबसे ज्यादा ग्राहक इसी कैटेगरी के हैं। कंपनियां इन ग्राहकों को इस तथ्य को देखते हुए भी लक्षित कर सकती हैं कि वे बड़ी संख्या में हैं।

नीचे बाईं ओर के ग्राहक (लेबल: 4, लाल) वे ग्राहक हैं जिनके पास कम वेतन और कम खर्च है, वे पदोन्नति की पेशकश करके आकर्षित हो सकते हैं।

और अंत में, ऊपर बाईं ओर के ग्राहक (लेबल: 3, नारंगी डेटा बिंदु) उच्च आय और कम खर्च वाले होते हैं, जिन्हें आदर्श रूप से विपणन द्वारा लक्षित किया जाता है।

पीसीए से परिणाम का उपयोग करना

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

clustering_model_pca = AgglomerativeClustering(n_clusters=5, affinity='euclidean', linkage='ward')
clustering_model_pca.fit(pcs)

data_labels_pca = clustering_model_pca.labels_

sns.scatterplot(x=pc1_values, 
                y=pc2_values,
                hue=data_labels_pca,
                palette="rainbow").set_title('Labeled Customer Data Reduced with PCA')

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

हमें अपने डेटा को जितना कम बदलना है, उतना अच्छा है।

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

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

आप हमेशा अपने डेटा की प्रकृति (रैखिक, गैर-रैखिक) के अनुसार अलग-अलग क्लस्टरिंग विज़ुअलाइज़ेशन तकनीकों का चयन कर सकते हैं और यदि आवश्यक हो तो उन सभी को संयोजित या परीक्षण कर सकते हैं।

निष्कर्ष

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

इस गाइड में, हम एक वास्तविक डेटा विज्ञान समस्या लेकर आए हैं, क्योंकि क्लस्टरिंग तकनीकों का उपयोग बड़े पैमाने पर विपणन विश्लेषण (और जैविक विश्लेषण में भी) में किया जाता है। हमने एक अच्छा पदानुक्रमित क्लस्टरिंग मॉडल प्राप्त करने के लिए कई जांच चरणों को भी समझाया है और डेंड्रोग्राम कैसे पढ़ा जाए और सवाल किया जाए कि क्या पीसीए एक आवश्यक कदम है। हमारा मुख्य उद्देश्य यह है कि कुछ नुकसान और विभिन्न परिदृश्य जिनमें हम पदानुक्रमित क्लस्टरिंग पा सकते हैं, को कवर किया गया है।

हैप्पी क्लस्टरिंग!