You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
632 lines
45 KiB
632 lines
45 KiB
{
|
|
"nbformat": 4,
|
|
"nbformat_minor": 0,
|
|
"metadata": {
|
|
"anaconda-cloud": "",
|
|
"kernelspec": {
|
|
"display_name": "R",
|
|
"language": "R",
|
|
"name": "ir"
|
|
},
|
|
"language_info": {
|
|
"codemirror_mode": "r",
|
|
"file_extension": ".r",
|
|
"mimetype": "text/x-r-source",
|
|
"name": "R",
|
|
"pygments_lexer": "r",
|
|
"version": "3.4.1"
|
|
},
|
|
"colab": {
|
|
"name": "lesson_14.ipynb",
|
|
"provenance": [],
|
|
"collapsed_sections": [],
|
|
"toc_visible": true
|
|
},
|
|
"coopTranslator": {
|
|
"original_hash": "ad65fb4aad0a156b42216e4929f490fc",
|
|
"translation_date": "2025-09-04T02:21:56+00:00",
|
|
"source_file": "5-Clustering/2-K-Means/solution/R/lesson_15-R.ipynb",
|
|
"language_code": "hi"
|
|
}
|
|
},
|
|
"cells": [
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "GULATlQXLXyR"
|
|
},
|
|
"source": [
|
|
"## आर और टाइडी डेटा सिद्धांतों का उपयोग करके K-Means क्लस्टरिंग का अन्वेषण करें\n",
|
|
"\n",
|
|
"### [**प्री-लेक्चर क्विज़**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/29/)\n",
|
|
"\n",
|
|
"इस पाठ में, आप सीखेंगे कि Tidymodels पैकेज और आर इकोसिस्टम के अन्य पैकेजों (जिन्हें हम दोस्त 🧑🤝🧑 कहेंगे) और पहले से आयात किए गए नाइजीरियाई संगीत डेटा सेट का उपयोग करके क्लस्टर कैसे बनाएं। हम क्लस्टरिंग के लिए K-Means की मूल बातें कवर करेंगे। ध्यान रखें कि, जैसा कि आपने पिछले पाठ में सीखा, क्लस्टर्स के साथ काम करने के कई तरीके हैं और आप जो तरीका उपयोग करते हैं वह आपके डेटा पर निर्भर करता है। हम K-Means आज़माएंगे क्योंकि यह सबसे सामान्य क्लस्टरिंग तकनीक है। चलिए शुरू करते हैं!\n",
|
|
"\n",
|
|
"आप जिन शब्दों के बारे में जानेंगे:\n",
|
|
"\n",
|
|
"- सिल्हूट स्कोरिंग \n",
|
|
"- एल्बो विधि \n",
|
|
"- इनर्शिया \n",
|
|
"- वैरिएंस \n",
|
|
"\n",
|
|
"### **परिचय**\n",
|
|
"\n",
|
|
"[K-Means क्लस्टरिंग](https://wikipedia.org/wiki/K-means_clustering) सिग्नल प्रोसेसिंग के क्षेत्र से निकली एक विधि है। इसका उपयोग डेटा के समूहों को उनकी विशेषताओं में समानताओं के आधार पर `k क्लस्टर्स` में विभाजित और वर्गीकृत करने के लिए किया जाता है।\n",
|
|
"\n",
|
|
"क्लस्टर्स को [वोरोनॉय डायग्राम्स](https://wikipedia.org/wiki/Voronoi_diagram) के रूप में देखा जा सकता है, जिसमें एक बिंदु (या 'बीज') और उसका संबंधित क्षेत्र शामिल होता है।\n",
|
|
"\n",
|
|
"<p >\n",
|
|
" <img src=\"../../images/voronoi.png\"\n",
|
|
" width=\"500\"/>\n",
|
|
" <figcaption>जेन लूपर द्वारा इन्फोग्राफिक</figcaption>\n",
|
|
"\n",
|
|
"K-Means क्लस्टरिंग के निम्नलिखित चरण होते हैं:\n",
|
|
"\n",
|
|
"1. डेटा वैज्ञानिक सबसे पहले यह निर्दिष्ट करता है कि कितने क्लस्टर्स बनाए जाने हैं। \n",
|
|
"2. इसके बाद, एल्गोरिदम डेटा सेट से K ऑब्ज़र्वेशन को यादृच्छिक रूप से चुनता है, जो क्लस्टर्स के प्रारंभिक केंद्र (यानी सेंट्रॉइड्स) के रूप में कार्य करते हैं। \n",
|
|
"3. फिर, शेष प्रत्येक ऑब्ज़र्वेशन को उसके निकटतम सेंट्रॉइड को सौंपा जाता है। \n",
|
|
"4. इसके बाद, प्रत्येक क्लस्टर का नया औसत गणना किया जाता है और सेंट्रॉइड को उस औसत पर ले जाया जाता है। \n",
|
|
"5. अब जब केंद्रों को पुनः गणना कर लिया गया है, तो प्रत्येक ऑब्ज़र्वेशन को फिर से जांचा जाता है कि क्या यह किसी अन्य क्लस्टर के करीब हो सकता है। सभी ऑब्ज़ेक्ट्स को अपडेट किए गए क्लस्टर औसत का उपयोग करके फिर से असाइन किया जाता है। क्लस्टर असाइनमेंट और सेंट्रॉइड अपडेट चरणों को तब तक दोहराया जाता है जब तक क्लस्टर असाइनमेंट बदलना बंद न कर दें (यानी, जब कन्वर्जेंस प्राप्त हो जाए)। आमतौर पर, एल्गोरिदम तब समाप्त होता है जब प्रत्येक नई पुनरावृत्ति में सेंट्रॉइड्स की नगण्य गति होती है और क्लस्टर्स स्थिर हो जाते हैं। \n",
|
|
"\n",
|
|
"<div>\n",
|
|
"\n",
|
|
"> ध्यान दें कि प्रारंभिक k ऑब्ज़र्वेशन के यादृच्छिक चयन के कारण, जो प्रारंभिक सेंट्रॉइड्स के रूप में उपयोग किए जाते हैं, हमें हर बार प्रक्रिया लागू करने पर थोड़े अलग परिणाम मिल सकते हैं। इस कारण से, अधिकांश एल्गोरिदम कई *यादृच्छिक प्रारंभ* का उपयोग करते हैं और सबसे कम WCSS वाले पुनरावृत्ति को चुनते हैं। इसलिए, यह दृढ़ता से अनुशंसा की जाती है कि हमेशा K-Means को कई *nstart* मानों के साथ चलाएं ताकि *अवांछनीय स्थानीय ऑप्टिमम* से बचा जा सके। \n",
|
|
"\n",
|
|
"</div>\n",
|
|
"\n",
|
|
"एलिसन हॉर्स्ट के [आर्टवर्क](https://github.com/allisonhorst/stats-illustrations) का उपयोग करते हुए यह छोटा एनीमेशन क्लस्टरिंग प्रक्रिया को समझाता है:\n",
|
|
"\n",
|
|
"<p >\n",
|
|
" <img src=\"../../images/kmeans.gif\"\n",
|
|
" width=\"550\"/>\n",
|
|
" <figcaption>@allison_horst द्वारा आर्टवर्क</figcaption>\n",
|
|
"\n",
|
|
"क्लस्टरिंग में एक मूलभूत प्रश्न यह उठता है: आप कैसे जानें कि अपने डेटा को कितने क्लस्टर्स में विभाजित करना है? K-Means का एक नुकसान यह है कि आपको `k`, यानी `सेंट्रॉइड्स` की संख्या स्थापित करनी होगी। सौभाग्य से, `एल्बो विधि` `k` के लिए एक अच्छा प्रारंभिक मान अनुमानित करने में मदद करती है। आप इसे अभी आज़माएंगे।\n",
|
|
"\n",
|
|
"### \n",
|
|
"\n",
|
|
"**पूर्वापेक्षा**\n",
|
|
"\n",
|
|
"हम वहीं से शुरू करेंगे जहां हमने [पिछले पाठ](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/1-Visualize/solution/R/lesson_14-R.ipynb) में छोड़ा था, जहां हमने डेटा सेट का विश्लेषण किया, कई विज़ुअलाइज़ेशन बनाए और डेटा सेट को रुचि के ऑब्ज़र्वेशन तक फ़िल्टर किया। इसे ज़रूर देखें!\n",
|
|
"\n",
|
|
"इस मॉड्यूल को पूरा करने के लिए हमें कुछ पैकेजों की आवश्यकता होगी। आप इन्हें इस प्रकार इंस्टॉल कर सकते हैं: `install.packages(c('tidyverse', 'tidymodels', 'cluster', 'summarytools', 'plotly', 'paletteer', 'factoextra', 'patchwork'))`\n",
|
|
"\n",
|
|
"वैकल्पिक रूप से, नीचे दिया गया स्क्रिप्ट जांचता है कि क्या आपके पास इस मॉड्यूल को पूरा करने के लिए आवश्यक पैकेज हैं और यदि कुछ गायब हैं तो उन्हें आपके लिए इंस्टॉल करता है। \n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "ah_tBi58LXyi"
|
|
},
|
|
"source": [
|
|
"suppressWarnings(if(!require(\"pacman\")) install.packages(\"pacman\"))\n",
|
|
"\n",
|
|
"pacman::p_load('tidyverse', 'tidymodels', 'cluster', 'summarytools', 'plotly', 'paletteer', 'factoextra', 'patchwork')\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "7e--UCUTLXym"
|
|
},
|
|
"source": [
|
|
"चलो तेजी से शुरुआत करते हैं!\n",
|
|
"\n",
|
|
"## 1. डेटा के साथ नृत्य: सबसे लोकप्रिय 3 संगीत शैलियों तक सीमित करें\n",
|
|
"\n",
|
|
"यह पिछले पाठ में किए गए कार्यों का पुनरावलोकन है। चलिए कुछ डेटा को छांटते और विश्लेषण करते हैं!\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "Ycamx7GGLXyn"
|
|
},
|
|
"source": [
|
|
"# Load the core tidyverse and make it available in your current R session\n",
|
|
"library(tidyverse)\n",
|
|
"\n",
|
|
"# Import the data into a tibble\n",
|
|
"df <- read_csv(file = \"https://raw.githubusercontent.com/microsoft/ML-For-Beginners/main/5-Clustering/data/nigerian-songs.csv\", show_col_types = FALSE)\n",
|
|
"\n",
|
|
"# Narrow down to top 3 popular genres\n",
|
|
"nigerian_songs <- df %>% \n",
|
|
" # Concentrate on top 3 genres\n",
|
|
" filter(artist_top_genre %in% c(\"afro dancehall\", \"afropop\",\"nigerian pop\")) %>% \n",
|
|
" # Remove unclassified observations\n",
|
|
" filter(popularity != 0)\n",
|
|
"\n",
|
|
"\n",
|
|
"\n",
|
|
"# Visualize popular genres using bar plots\n",
|
|
"theme_set(theme_light())\n",
|
|
"nigerian_songs %>%\n",
|
|
" count(artist_top_genre) %>%\n",
|
|
" ggplot(mapping = aes(x = artist_top_genre, y = n,\n",
|
|
" fill = artist_top_genre)) +\n",
|
|
" geom_col(alpha = 0.8) +\n",
|
|
" paletteer::scale_fill_paletteer_d(\"ggsci::category10_d3\") +\n",
|
|
" ggtitle(\"Top genres\") +\n",
|
|
" theme(plot.title = element_text(hjust = 0.5))\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "b5h5zmkPLXyp"
|
|
},
|
|
"source": [
|
|
"🤩 यह अच्छा रहा!\n",
|
|
"\n",
|
|
"## 2. डेटा की और अधिक खोजबीन।\n",
|
|
"\n",
|
|
"यह डेटा कितना साफ-सुथरा है? चलिए बॉक्स प्लॉट्स का उपयोग करके आउटलायर्स की जांच करते हैं। हम उन संख्यात्मक कॉलम्स पर ध्यान केंद्रित करेंगे जिनमें कम आउटलायर्स हैं (हालांकि आप आउटलायर्स को साफ कर सकते हैं)। बॉक्स प्लॉट्स डेटा की रेंज दिखा सकते हैं और यह तय करने में मदद करेंगे कि किन कॉलम्स का उपयोग करना है। ध्यान दें, बॉक्स प्लॉट्स वेरिएंस नहीं दिखाते हैं, जो कि अच्छे क्लस्टरेबल डेटा का एक महत्वपूर्ण तत्व है। कृपया [इस चर्चा](https://stats.stackexchange.com/questions/91536/deduce-variance-from-boxplot) को और पढ़ें।\n",
|
|
"\n",
|
|
"[बॉक्स प्लॉट्स](https://en.wikipedia.org/wiki/Box_plot) का उपयोग `संख्यात्मक` डेटा के वितरण को ग्राफिक रूप से दिखाने के लिए किया जाता है, तो चलिए लोकप्रिय संगीत शैलियों के साथ सभी संख्यात्मक कॉलम्स को *चुनने* से शुरू करते हैं।\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "HhNreJKLLXyq"
|
|
},
|
|
"source": [
|
|
"# Select top genre column and all other numeric columns\n",
|
|
"df_numeric <- nigerian_songs %>% \n",
|
|
" select(artist_top_genre, where(is.numeric)) \n",
|
|
"\n",
|
|
"# Display the data\n",
|
|
"df_numeric %>% \n",
|
|
" slice_head(n = 5)\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "uYXrwJRaLXyq"
|
|
},
|
|
"source": [
|
|
"देखें कि चयन सहायक `where` इसे कितना आसान बनाता है 💁? ऐसे अन्य फ़ंक्शन्स को [यहां](https://tidyselect.r-lib.org/) एक्सप्लोर करें।\n",
|
|
"\n",
|
|
"चूंकि हम प्रत्येक संख्यात्मक विशेषता के लिए एक बॉक्सप्लॉट बनाएंगे और लूप्स का उपयोग करने से बचना चाहते हैं, तो चलिए अपने डेटा को *लंबे* प्रारूप में पुनः व्यवस्थित करते हैं, जो हमें `facets` का लाभ उठाने की अनुमति देगा - उप-ग्राफ जो डेटा के प्रत्येक उपसेट को प्रदर्शित करते हैं।\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "gd5bR3f8LXys"
|
|
},
|
|
"source": [
|
|
"# Pivot data from wide to long\n",
|
|
"df_numeric_long <- df_numeric %>% \n",
|
|
" pivot_longer(!artist_top_genre, names_to = \"feature_names\", values_to = \"values\") \n",
|
|
"\n",
|
|
"# Print out data\n",
|
|
"df_numeric_long %>% \n",
|
|
" slice_head(n = 15)\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "-7tE1swnLXyv"
|
|
},
|
|
"source": [
|
|
"अब कुछ और लंबा! अब समय है कुछ `ggplots` का! तो हम कौन सा `geom` इस्तेमाल करेंगे?\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "r88bIsyuLXyy"
|
|
},
|
|
"source": [
|
|
"# Make a box plot\n",
|
|
"df_numeric_long %>% \n",
|
|
" ggplot(mapping = aes(x = feature_names, y = values, fill = feature_names)) +\n",
|
|
" geom_boxplot() +\n",
|
|
" facet_wrap(~ feature_names, ncol = 4, scales = \"free\") +\n",
|
|
" theme(legend.position = \"none\")\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "EYVyKIUELXyz"
|
|
},
|
|
"source": [
|
|
"आसान-जीजी!\n",
|
|
"\n",
|
|
"अब हम देख सकते हैं कि यह डेटा थोड़ा शोरयुक्त है: प्रत्येक कॉलम को बॉक्सप्लॉट के रूप में देखकर, आप आउटलायर्स देख सकते हैं। आप डेटा सेट में जाकर इन आउटलायर्स को हटा सकते हैं, लेकिन इससे डेटा बहुत कम हो जाएगा।\n",
|
|
"\n",
|
|
"फिलहाल, चलिए तय करते हैं कि हम अपने क्लस्टरिंग अभ्यास के लिए कौन से कॉलम का उपयोग करेंगे। चलिए उन्हीं न्यूमेरिक कॉलम्स को चुनते हैं जिनकी रेंज समान है। हम `artist_top_genre` को न्यूमेरिक के रूप में एन्कोड कर सकते थे, लेकिन फिलहाल इसे छोड़ देते हैं।\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "-wkpINyZLXy0"
|
|
},
|
|
"source": [
|
|
"# Select variables with similar ranges\n",
|
|
"df_numeric_select <- df_numeric %>% \n",
|
|
" select(popularity, danceability, acousticness, loudness, energy) \n",
|
|
"\n",
|
|
"# Normalize data\n",
|
|
"# df_numeric_select <- scale(df_numeric_select)\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "D7dLzgpqLXy1"
|
|
},
|
|
"source": [
|
|
"## 3. R में k-means क्लस्टरिंग की गणना करना\n",
|
|
"\n",
|
|
"हम R में बिल्ट-इन `kmeans` फ़ंक्शन का उपयोग करके k-means की गणना कर सकते हैं, देखें `help(\"kmeans()\")`। `kmeans()` फ़ंक्शन का मुख्य तर्क एक डेटा फ्रेम है जिसमें सभी कॉलम संख्यात्मक होते हैं।\n",
|
|
"\n",
|
|
"k-means क्लस्टरिंग का उपयोग करते समय पहला कदम यह तय करना होता है कि अंतिम समाधान में कितने क्लस्टर (k) बनाए जाएंगे। हमें पता है कि डेटा सेट से हमने 3 गाने की शैलियों को निकाला है, तो चलिए 3 का प्रयास करते हैं:\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "uC4EQ5w7LXy5"
|
|
},
|
|
"source": [
|
|
"set.seed(2056)\n",
|
|
"# Kmeans clustering for 3 clusters\n",
|
|
"kclust <- kmeans(\n",
|
|
" df_numeric_select,\n",
|
|
" # Specify the number of clusters\n",
|
|
" centers = 3,\n",
|
|
" # How many random initial configurations\n",
|
|
" nstart = 25\n",
|
|
")\n",
|
|
"\n",
|
|
"# Display clustering object\n",
|
|
"kclust\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "hzfhscWrLXy-"
|
|
},
|
|
"source": [
|
|
"kmeans ऑब्जेक्ट में कई प्रकार की जानकारी होती है, जिसे `help(\"kmeans()\")` में अच्छी तरह से समझाया गया है। फिलहाल, आइए कुछ मुख्य बिंदुओं पर ध्यान दें। हम देखते हैं कि डेटा को 3 क्लस्टर्स में विभाजित किया गया है, जिनके आकार 65, 110, 111 हैं। आउटपुट में 5 वेरिएबल्स के आधार पर इन 3 समूहों के क्लस्टर सेंटर्स (औसत) भी शामिल हैं।\n",
|
|
"\n",
|
|
"क्लस्टरिंग वेक्टर प्रत्येक ऑब्ज़र्वेशन के लिए क्लस्टर असाइनमेंट को दर्शाता है। आइए `augment` फंक्शन का उपयोग करके मूल डेटा सेट में क्लस्टर असाइनमेंट जोड़ें।\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "0XwwpFGQLXy_"
|
|
},
|
|
"source": [
|
|
"# Add predicted cluster assignment to data set\n",
|
|
"augment(kclust, df_numeric_select) %>% \n",
|
|
" relocate(.cluster) %>% \n",
|
|
" slice_head(n = 10)\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "NXIVXXACLXzA"
|
|
},
|
|
"source": [
|
|
"हमने अभी-अभी अपने डेटा सेट को 3 समूहों में विभाजित किया है। तो, हमारी क्लस्टरिंग कितनी अच्छी है 🤷? आइए `Silhouette score` पर नज़र डालते हैं।\n",
|
|
"\n",
|
|
"### **Silhouette स्कोर**\n",
|
|
"\n",
|
|
"[Silhouette विश्लेषण](https://en.wikipedia.org/wiki/Silhouette_(clustering)) का उपयोग परिणामस्वरूप बने क्लस्टर्स के बीच की दूरी का अध्ययन करने के लिए किया जा सकता है। यह स्कोर -1 से 1 के बीच होता है, और यदि स्कोर 1 के करीब है, तो क्लस्टर घना और अन्य क्लस्टर्स से अच्छी तरह से अलग होता है। 0 के करीब का मान उन क्लस्टर्स को दर्शाता है जो ओवरलैप हो रहे हैं और जिनके सैंपल पड़ोसी क्लस्टर्स की निर्णय सीमा के बहुत करीब हैं। [स्रोत](https://dzone.com/articles/kmeans-silhouette-score-explained-with-python-exam)।\n",
|
|
"\n",
|
|
"औसत Silhouette विधि विभिन्न *k* मानों के लिए ऑब्ज़र्वेशन्स के औसत Silhouette की गणना करती है। उच्च औसत Silhouette स्कोर एक अच्छी क्लस्टरिंग को इंगित करता है।\n",
|
|
"\n",
|
|
"`silhouette` फ़ंक्शन का उपयोग क्लस्टर पैकेज में औसत Silhouette चौड़ाई की गणना के लिए किया जाता है।\n",
|
|
"\n",
|
|
"> Silhouette को किसी भी [दूरी](https://en.wikipedia.org/wiki/Distance \"Distance\") मीट्रिक के साथ गणना की जा सकती है, जैसे कि [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance \"Euclidean distance\") या [Manhattan distance](https://en.wikipedia.org/wiki/Manhattan_distance \"Manhattan distance\"), जिन पर हमने [पिछले पाठ](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/1-Visualize/solution/R/lesson_14-R.ipynb) में चर्चा की थी।\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "Jn0McL28LXzB"
|
|
},
|
|
"source": [
|
|
"# Load cluster package\n",
|
|
"library(cluster)\n",
|
|
"\n",
|
|
"# Compute average silhouette score\n",
|
|
"ss <- silhouette(kclust$cluster,\n",
|
|
" # Compute euclidean distance\n",
|
|
" dist = dist(df_numeric_select))\n",
|
|
"mean(ss[, 3])\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "QyQRn97nLXzC"
|
|
},
|
|
"source": [
|
|
"हमारा स्कोर **.549** है, जो ठीक बीच में आता है। इसका मतलब है कि हमारा डेटा इस प्रकार के क्लस्टरिंग के लिए विशेष रूप से उपयुक्त नहीं है। चलिए देखते हैं कि क्या हम इस अनुमान को विज़ुअली पुष्टि कर सकते हैं। [factoextra पैकेज](https://rpkgs.datanovia.com/factoextra/index.html) क्लस्टरिंग को विज़ुअलाइज़ करने के लिए फंक्शन्स (`fviz_cluster()`) प्रदान करता है।\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "7a6Km1_FLXzD"
|
|
},
|
|
"source": [
|
|
"library(factoextra)\n",
|
|
"\n",
|
|
"# Visualize clustering results\n",
|
|
"fviz_cluster(kclust, df_numeric_select)\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "IBwCWt-0LXzD"
|
|
},
|
|
"source": [
|
|
"क्लस्टर्स में ओवरलैप यह दर्शाता है कि हमारा डेटा इस प्रकार के क्लस्टरिंग के लिए विशेष रूप से उपयुक्त नहीं है, लेकिन चलिए आगे बढ़ते हैं।\n",
|
|
"\n",
|
|
"## 4. इष्टतम क्लस्टर्स का निर्धारण\n",
|
|
"\n",
|
|
"K-Means क्लस्टरिंग में अक्सर उठने वाला एक बुनियादी सवाल यह है - जब वर्ग लेबल ज्ञात नहीं होते, तो आप कैसे तय करेंगे कि अपने डेटा को कितने क्लस्टर्स में विभाजित करना है?\n",
|
|
"\n",
|
|
"हम इसे जानने के लिए एक तरीका आज़मा सकते हैं: `क्लस्टरिंग मॉडल्स की एक श्रृंखला बनाएं` जिसमें क्लस्टर्स की संख्या को क्रमिक रूप से बढ़ाया जाए (जैसे 1 से 10 तक), और क्लस्टरिंग मेट्रिक्स जैसे **सिलुएट स्कोर** का मूल्यांकन करें।\n",
|
|
"\n",
|
|
"आइए, *k* के विभिन्न मानों के लिए क्लस्टरिंग एल्गोरिदम को चलाकर और **Within Cluster Sum of Squares** (WCSS) का मूल्यांकन करके इष्टतम क्लस्टर्स की संख्या निर्धारित करें। कुल within-cluster sum of square (WCSS) क्लस्टरिंग की कॉम्पैक्टनेस को मापता है, और हम इसे यथासंभव छोटा रखना चाहते हैं, क्योंकि छोटे मान यह दर्शाते हैं कि डेटा पॉइंट्स एक-दूसरे के करीब हैं।\n",
|
|
"\n",
|
|
"आइए, 1 से 10 तक के `k` के विभिन्न विकल्पों का इस क्लस्टरिंग पर प्रभाव देखें।\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "hSeIiylDLXzE"
|
|
},
|
|
"source": [
|
|
"# Create a series of clustering models\n",
|
|
"kclusts <- tibble(k = 1:10) %>% \n",
|
|
" # Perform kmeans clustering for 1,2,3 ... ,10 clusters\n",
|
|
" mutate(model = map(k, ~ kmeans(df_numeric_select, centers = .x, nstart = 25)),\n",
|
|
" # Farm out clustering metrics eg WCSS\n",
|
|
" glanced = map(model, ~ glance(.x))) %>% \n",
|
|
" unnest(cols = glanced)\n",
|
|
" \n",
|
|
"\n",
|
|
"# View clustering rsulsts\n",
|
|
"kclusts\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "m7rS2U1eLXzE"
|
|
},
|
|
"source": [
|
|
"अब जब हमारे पास प्रत्येक क्लस्टरिंग एल्गोरिदम के लिए केंद्र *k* के साथ कुल क्लस्टर के भीतर का योग (tot.withinss) है, तो हम [एल्बो विधि](https://en.wikipedia.org/wiki/Elbow_method_(clustering)) का उपयोग करके क्लस्टर्स की आदर्श संख्या का पता लगाते हैं। इस विधि में WCSS को क्लस्टर्स की संख्या के अनुसार प्लॉट करना शामिल है, और [वक्र के एल्बो](https://en.wikipedia.org/wiki/Elbow_of_the_curve \"Elbow of the curve\") को क्लस्टर्स की संख्या के रूप में चुनना होता है।\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "o_DjHGItLXzF"
|
|
},
|
|
"source": [
|
|
"set.seed(2056)\n",
|
|
"# Use elbow method to determine optimum number of clusters\n",
|
|
"kclusts %>% \n",
|
|
" ggplot(mapping = aes(x = k, y = tot.withinss)) +\n",
|
|
" geom_line(size = 1.2, alpha = 0.8, color = \"#FF7F0EFF\") +\n",
|
|
" geom_point(size = 2, color = \"#FF7F0EFF\")\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "pLYyt5XSLXzG"
|
|
},
|
|
"source": [
|
|
"प्लॉट दिखाता है कि जब क्लस्टर्स की संख्या एक से दो तक बढ़ती है, तो WCSS (अर्थात *सघनता*) में बड़ी कमी होती है, और दो से तीन क्लस्टर्स तक एक और ध्यान देने योग्य कमी होती है। इसके बाद, कमी कम स्पष्ट हो जाती है, जिससे चार्ट में लगभग तीन क्लस्टर्स पर एक `कोहनी` 💪 बनती है। यह इस बात का अच्छा संकेत है कि डेटा पॉइंट्स के दो से तीन उचित रूप से अलग-अलग क्लस्टर्स हैं।\n",
|
|
"\n",
|
|
"अब हम आगे बढ़ सकते हैं और वह क्लस्टरिंग मॉडल निकाल सकते हैं जहाँ `k = 3` है:\n",
|
|
"\n",
|
|
"> `pull()`: एक सिंगल कॉलम निकालने के लिए उपयोग किया जाता है \n",
|
|
">\n",
|
|
"> `pluck()`: लिस्ट जैसी डेटा संरचनाओं को इंडेक्स करने के लिए उपयोग किया जाता है \n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "JP_JPKBILXzG"
|
|
},
|
|
"source": [
|
|
"# Extract k = 3 clustering\n",
|
|
"final_kmeans <- kclusts %>% \n",
|
|
" filter(k == 3) %>% \n",
|
|
" pull(model) %>% \n",
|
|
" pluck(1)\n",
|
|
"\n",
|
|
"\n",
|
|
"final_kmeans\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "l_PDTu8tLXzI"
|
|
},
|
|
"source": [
|
|
"आइए प्राप्त किए गए क्लस्टर्स को विज़ुअलाइज़ करें। क्या आप `plotly` का उपयोग करके कुछ इंटरएक्टिविटी चाहते हैं?\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "dNcleFe-LXzJ"
|
|
},
|
|
"source": [
|
|
"# Add predicted cluster assignment to data set\n",
|
|
"results <- augment(final_kmeans, df_numeric_select) %>% \n",
|
|
" bind_cols(df_numeric %>% select(artist_top_genre)) \n",
|
|
"\n",
|
|
"# Plot cluster assignments\n",
|
|
"clust_plt <- results %>% \n",
|
|
" ggplot(mapping = aes(x = popularity, y = danceability, color = .cluster, shape = artist_top_genre)) +\n",
|
|
" geom_point(size = 2, alpha = 0.8) +\n",
|
|
" paletteer::scale_color_paletteer_d(\"ggthemes::Tableau_10\")\n",
|
|
"\n",
|
|
"ggplotly(clust_plt)\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "6JUM_51VLXzK"
|
|
},
|
|
"source": [
|
|
"शायद हम यह उम्मीद कर सकते थे कि प्रत्येक क्लस्टर (जो विभिन्न रंगों द्वारा दर्शाए गए हैं) के पास अलग-अलग शैलियाँ (जो विभिन्न आकारों द्वारा दर्शाई गई हैं) होंगी।\n",
|
|
"\n",
|
|
"आइए मॉडल की सटीकता पर एक नज़र डालें।\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "code",
|
|
"metadata": {
|
|
"id": "HdIMUGq7LXzL"
|
|
},
|
|
"source": [
|
|
"# Assign genres to predefined integers\n",
|
|
"label_count <- results %>% \n",
|
|
" group_by(artist_top_genre) %>% \n",
|
|
" mutate(id = cur_group_id()) %>% \n",
|
|
" ungroup() %>% \n",
|
|
" summarise(correct_labels = sum(.cluster == id))\n",
|
|
"\n",
|
|
"\n",
|
|
"# Print results \n",
|
|
"cat(\"Result:\", label_count$correct_labels, \"out of\", nrow(results), \"samples were correctly labeled.\")\n",
|
|
"\n",
|
|
"cat(\"\\nAccuracy score:\", label_count$correct_labels/nrow(results))\n"
|
|
],
|
|
"execution_count": null,
|
|
"outputs": []
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {
|
|
"id": "C50wvaAOLXzM"
|
|
},
|
|
"source": [
|
|
"इस मॉडल की सटीकता बुरी नहीं है, लेकिन बहुत अच्छी भी नहीं है। हो सकता है कि यह डेटा K-Means क्लस्टरिंग के लिए उपयुक्त न हो। यह डेटा बहुत असंतुलित है, आपस में कम संबंधित है, और कॉलम मानों के बीच बहुत अधिक विविधता है, जिससे क्लस्टरिंग अच्छी तरह से नहीं हो पाती। वास्तव में, जो क्लस्टर बनते हैं, वे शायद ऊपर परिभाषित तीन जेनर श्रेणियों से काफी प्रभावित या विकृत होते हैं।\n",
|
|
"\n",
|
|
"फिर भी, यह एक अच्छा सीखने का अनुभव था!\n",
|
|
"\n",
|
|
"Scikit-learn के दस्तावेज़ में, आप देख सकते हैं कि इस तरह के मॉडल में, जहां क्लस्टर बहुत स्पष्ट रूप से परिभाषित नहीं हैं, 'वैरिएंस' की समस्या होती है:\n",
|
|
"\n",
|
|
"<p >\n",
|
|
" <img src=\"../../images/problems.png\"\n",
|
|
" width=\"500\"/>\n",
|
|
" <figcaption>Scikit-learn से लिया गया इन्फोग्राफिक</figcaption>\n",
|
|
"\n",
|
|
"\n",
|
|
"\n",
|
|
"## **वैरिएंस**\n",
|
|
"\n",
|
|
"वैरिएंस को \"औसत से वर्गीय अंतर का औसत\" के रूप में परिभाषित किया गया है [स्रोत](https://www.mathsisfun.com/data/standard-deviation.html)। इस क्लस्टरिंग समस्या के संदर्भ में, इसका मतलब है कि हमारे डेटा सेट के नंबर औसत से बहुत अधिक विचलित हो रहे हैं।\n",
|
|
"\n",
|
|
"✅ यह एक अच्छा समय है इस समस्या को हल करने के तरीकों पर विचार करने का। डेटा को थोड़ा और समायोजित करें? अलग-अलग कॉलम का उपयोग करें? कोई अलग एल्गोरिदम आज़माएं? संकेत: अपने डेटा को [स्केल करें](https://www.mygreatlearning.com/blog/learning-data-science-with-k-means-clustering/) ताकि इसे सामान्यीकृत किया जा सके और अन्य कॉलम का परीक्षण करें।\n",
|
|
"\n",
|
|
"> इस '[वैरिएंस कैलकुलेटर](https://www.calculatorsoup.com/calculators/statistics/variance-calculator.php)' का उपयोग करके इस अवधारणा को और बेहतर समझें।\n",
|
|
"\n",
|
|
"------------------------------------------------------------------------\n",
|
|
"\n",
|
|
"## **🚀चुनौती**\n",
|
|
"\n",
|
|
"इस नोटबुक के साथ कुछ समय बिताएं और पैरामीटर को समायोजित करें। क्या आप डेटा को और साफ करके (जैसे, आउटलायर्स को हटाकर) मॉडल की सटीकता सुधार सकते हैं? आप कुछ डेटा सैंपल्स को अधिक वेट दे सकते हैं। बेहतर क्लस्टर बनाने के लिए और क्या किया जा सकता है?\n",
|
|
"\n",
|
|
"संकेत: अपने डेटा को स्केल करने का प्रयास करें। नोटबुक में कमेंटेड कोड है जो स्टैंडर्ड स्केलिंग जोड़ता है ताकि डेटा कॉलम रेंज के मामले में एक-दूसरे से अधिक मेल खा सकें। आप पाएंगे कि जबकि सिलोएट स्कोर कम हो जाता है, एल्बो ग्राफ में 'किंक' स्मूद हो जाता है। ऐसा इसलिए है क्योंकि डेटा को बिना स्केल किए छोड़ने से कम वैरिएंस वाले डेटा को अधिक वेट मिल जाता है। इस समस्या पर और पढ़ें [यहां](https://stats.stackexchange.com/questions/21222/are-mean-normalization-and-feature-scaling-needed-for-k-means-clustering/21226#21226)।\n",
|
|
"\n",
|
|
"## [**पोस्ट-लेक्चर क्विज़**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/30/)\n",
|
|
"\n",
|
|
"## **समीक्षा और स्व-अध्ययन**\n",
|
|
"\n",
|
|
"- K-Means सिम्युलेटर [जैसे इस](https://user.ceng.metu.edu.tr/~akifakkus/courses/ceng574/k-means/) को देखें। आप इस टूल का उपयोग सैंपल डेटा पॉइंट्स को विज़ुअलाइज़ करने और उनके सेंट्रॉइड्स निर्धारित करने के लिए कर सकते हैं। आप डेटा की रैंडमनेस, क्लस्टर्स की संख्या और सेंट्रॉइड्स की संख्या को एडिट कर सकते हैं। क्या इससे आपको यह समझने में मदद मिलती है कि डेटा को कैसे ग्रुप किया जा सकता है?\n",
|
|
"\n",
|
|
"- [K-Means पर यह हैंडआउट](https://stanford.edu/~cpiech/cs221/handouts/kmeans.html) स्टैनफोर्ड से भी देखें।\n",
|
|
"\n",
|
|
"क्या आप अपने नए सीखे गए क्लस्टरिंग कौशल को उन डेटा सेट्स पर आज़माना चाहते हैं जो K-Means क्लस्टरिंग के लिए उपयुक्त हैं? कृपया देखें:\n",
|
|
"\n",
|
|
"- [क्लस्टरिंग मॉडल्स को ट्रेन और इवैल्यूएट करें](https://rpubs.com/eR_ic/clustering) Tidymodels और उनके साथियों का उपयोग करके\n",
|
|
"\n",
|
|
"- [K-Means क्लस्टर एनालिसिस](https://uc-r.github.io/kmeans_clustering), UC बिज़नेस एनालिटिक्स R प्रोग्रामिंग गाइड\n",
|
|
"\n",
|
|
"- [टिडी डेटा प्रिंसिपल्स के साथ K-Means क्लस्टरिंग](https://www.tidymodels.org/learn/statistics/k-means/)\n",
|
|
"\n",
|
|
"## **असाइनमेंट**\n",
|
|
"\n",
|
|
"[अलग-अलग क्लस्टरिंग विधियों को आज़माएं](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/2-K-Means/assignment.md)\n",
|
|
"\n",
|
|
"## धन्यवाद:\n",
|
|
"\n",
|
|
"[जेन लूपर](https://www.twitter.com/jenlooper) को इस मॉड्यूल के मूल Python संस्करण को बनाने के लिए ♥️\n",
|
|
"\n",
|
|
"[`एलिसन हॉर्स्ट`](https://twitter.com/allison_horst/) को अद्भुत चित्रण बनाने के लिए जो R को अधिक स्वागतयोग्य और आकर्षक बनाते हैं। उनके और चित्रण [यहां](https://www.google.com/url?q=https://github.com/allisonhorst/stats-illustrations&sa=D&source=editors&ust=1626380772530000&usg=AOvVaw3zcfyCizFQZpkSLzxiiQEM) देखें।\n",
|
|
"\n",
|
|
"खुशहाल सीखना,\n",
|
|
"\n",
|
|
"[एरिक](https://twitter.com/ericntay), गोल्ड माइक्रोसॉफ्ट लर्न स्टूडेंट एंबेसडर।\n",
|
|
"\n",
|
|
"<p >\n",
|
|
" <img src=\"../../images/r_learners_sm.jpeg\"\n",
|
|
" width=\"500\"/>\n",
|
|
" <figcaption>@allison_horst द्वारा आर्टवर्क</figcaption>\n"
|
|
]
|
|
},
|
|
{
|
|
"cell_type": "markdown",
|
|
"metadata": {},
|
|
"source": [
|
|
"\n---\n\n**अस्वीकरण**: \nयह दस्तावेज़ AI अनुवाद सेवा [Co-op Translator](https://github.com/Azure/co-op-translator) का उपयोग करके अनुवादित किया गया है। जबकि हम सटीकता के लिए प्रयासरत हैं, कृपया ध्यान दें कि स्वचालित अनुवाद में त्रुटियां या अशुद्धियां हो सकती हैं। मूल भाषा में उपलब्ध मूल दस्तावेज़ को आधिकारिक स्रोत माना जाना चाहिए। महत्वपूर्ण जानकारी के लिए, पेशेवर मानव अनुवाद की सिफारिश की जाती है। इस अनुवाद के उपयोग से उत्पन्न किसी भी गलतफहमी या गलत व्याख्या के लिए हम उत्तरदायी नहीं हैं।\n"
|
|
]
|
|
}
|
|
]
|
|
} |