{
 "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-08-29T19:20:23+00:00",
   "source_file": "5-Clustering/2-K-Means/solution/R/lesson_15-R.ipynb",
   "language_code": "mr"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GULATlQXLXyR"
   },
   "source": [
    "## R आणि Tidy डेटा तत्त्वांचा वापर करून K-Means क्लस्टरिंग एक्सप्लोर करा.\n",
    "\n",
    "### [**पूर्व-व्याख्यान प्रश्नमंजुषा**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/29/)\n",
    "\n",
    "या धड्यात, तुम्ही Tidymodels पॅकेज आणि R इकोसिस्टममधील इतर पॅकेजेस (आपण त्यांना मित्र म्हणू 🧑‍🤝‍🧑) वापरून क्लस्टर कसे तयार करायचे ते शिकाल, तसेच तुम्ही यापूर्वी आयात केलेल्या नायजेरियन संगीत डेटासेटवर काम कराल. आपण क्लस्टरिंगसाठी K-Means च्या मूलभूत गोष्टींचा अभ्यास करू. लक्षात ठेवा, जसे तुम्ही मागील धड्यात शिकले, क्लस्टरिंगसाठी अनेक पद्धती आहेत आणि तुम्ही कोणती पद्धत वापरता हे तुमच्या डेटावर अवलंबून असते. आपण K-Means वापरून पाहू, कारण ही सर्वात सामान्य क्लस्टरिंग तंत्र आहे. चला सुरुवात करूया!\n",
    "\n",
    "तुम्ही शिकणार असलेल्या संज्ञा:\n",
    "\n",
    "-   सिल्हूट स्कोअरिंग\n",
    "\n",
    "-   एल्बो पद्धत\n",
    "\n",
    "-   इनर्शिया\n",
    "\n",
    "-   व्हेरियन्स\n",
    "\n",
    "### **परिचय**\n",
    "\n",
    "[K-Means Clustering](https://wikipedia.org/wiki/K-means_clustering) ही सिग्नल प्रोसेसिंगच्या क्षेत्रातून आलेली पद्धत आहे. ती डेटाच्या वैशिष्ट्यांमधील समानतेच्या आधारे `k क्लस्टर` मध्ये गट विभाजित आणि विभागण्यासाठी वापरली जाते.\n",
    "\n",
    "क्लस्टर [Voronoi diagrams](https://wikipedia.org/wiki/Voronoi_diagram) म्हणून व्हिज्युअलाइझ केले जाऊ शकतात, ज्यामध्ये एक बिंदू (किंवा 'बीज') आणि त्याचा संबंधित प्रदेश समाविष्ट असतो.\n",
    "\n",
    "<p >\n",
    "   <img src=\"../../images/voronoi.png\"\n",
    "   width=\"500\"/>\n",
    "   <figcaption>Jen Looper द्वारे माहितीग्राफिक</figcaption>\n",
    "\n",
    "\n",
    "K-Means क्लस्टरिंगचे खालील टप्पे आहेत:\n",
    "\n",
    "1. डेटा वैज्ञानिक इच्छित क्लस्टरची संख्या निर्दिष्ट करून सुरुवात करतो.\n",
    "\n",
    "2. त्यानंतर, अल्गोरिदम डेटासेटमधून K निरीक्षणे निवडतो जी क्लस्टरच्या सुरुवातीच्या केंद्रे (म्हणजेच, सेंटरॉइड्स) म्हणून काम करतात.\n",
    "\n",
    "3. त्यानंतर, उर्वरित प्रत्येक निरीक्षण त्याच्या सर्वात जवळच्या सेंटरॉइडला नियुक्त केले जाते.\n",
    "\n",
    "4. त्यानंतर, प्रत्येक क्लस्टरचा नवीन सरासरी गणना केली जाते आणि सेंटरॉइड सरासरीकडे हलवला जातो.\n",
    "\n",
    "5. आता केंद्रे पुन्हा गणना केल्यानंतर, प्रत्येक निरीक्षण पुन्हा तपासले जाते की ते वेगळ्या क्लस्टरच्या जवळ असू शकते का. सर्व ऑब्जेक्ट्स पुन्हा अद्यतनित क्लस्टर सरासरी वापरून पुनर्नियुक्त केले जातात. क्लस्टर असाइनमेंट आणि सेंटरॉइड अपडेट टप्पे पुनरावृत्तीने केले जातात जोपर्यंत क्लस्टर असाइनमेंट बदलणे थांबत नाही (म्हणजेच, जेव्हा अभिसरण साध्य होते). सामान्यतः, अल्गोरिदम प्रत्येक नवीन पुनरावृत्तीमध्ये सेंटरॉइड्सच्या नगण्य हालचालींमुळे समाप्त होतो आणि क्लस्टर स्थिर होतात.\n",
    "\n",
    "<div>\n",
    "\n",
    "> लक्षात ठेवा की सुरुवातीच्या k निरीक्षणांच्या यादृच्छिक निवडीमुळे, जी सुरुवातीच्या सेंटरॉइड्स म्हणून वापरली जाते, प्रत्येक वेळी प्रक्रिया लागू केल्यावर आपल्याला किंचित वेगळे परिणाम मिळू शकतात. यामुळे, बहुतेक अल्गोरिदम अनेक *यादृच्छिक प्रारंभ* वापरतात आणि सर्वात कमी WCSS असलेल्या पुनरावृत्तीची निवड करतात. म्हणूनच, *अवांछनीय स्थानिक ऑप्टिमम* टाळण्यासाठी नेहमी K-Means अनेक *nstart* मूल्यांसह चालवण्याची जोरदार शिफारस केली जाते.\n",
    "\n",
    "</div>\n",
    "\n",
    "Allison Horst च्या [कलेचा](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",
    "\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",
    "हा डेटा किती स्वच्छ आहे? बॉक्स प्लॉट्स वापरून बाहेरच्या मूल्यांची तपासणी करूया. आपण अशा संख्यात्मक स्तंभांवर लक्ष केंद्रित करू जेथे बाहेरची मूल्ये कमी आहेत (जरी तुम्ही बाहेरची मूल्ये साफ करू शकता). बॉक्स प्लॉट्स डेटाचा श्रेणी दर्शवू शकतात आणि कोणते स्तंभ वापरायचे ते निवडण्यास मदत करतील. लक्षात घ्या, बॉक्स प्लॉट्स वैविध्य (variance) दाखवत नाहीत, जे चांगल्या क्लस्टर करण्यायोग्य डेटाचे एक महत्त्वाचे घटक आहे. कृपया अधिक वाचनासाठी [ही चर्चा](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",
    "सध्या, आपण क्लस्टरिंग सरावासाठी कोणते स्तंभ वापरायचे ते निवडूया. समान श्रेणी असलेल्या संख्यात्मक स्तंभांची निवड करूया. आपण `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()\")` मध्ये चांगल्या प्रकारे समजावून सांगितली आहे. सध्या, आपण काही गोष्टींवर लक्ष केंद्रित करूया. आपल्याला दिसते की डेटा 65, 110, 111 आकारांच्या 3 क्लस्टर्समध्ये गटबद्ध केला गेला आहे. आउटपुटमध्ये 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 score**\n",
    "\n",
    "[Silhouette analysis](https://en.wikipedia.org/wiki/Silhouette_(clustering)) चा उपयोग तयार झालेल्या क्लस्टर्समधील विभाजन अंतर अभ्यासण्यासाठी केला जाऊ शकतो. हा स्कोअर -1 ते 1 पर्यंत बदलतो, आणि जर स्कोअर 1 च्या जवळ असेल, तर क्लस्टर घन आणि इतर क्लस्टर्सपासून चांगल्या प्रकारे वेगळे असते. 0 च्या जवळचा मूल्य दर्शवतो की क्लस्टर्स ओव्हरलॅप होत आहेत आणि नमुने शेजारच्या क्लस्टर्सच्या निर्णय सीमा जवळ आहेत. [source](https://dzone.com/articles/kmeans-silhouette-score-explained-with-python-exam).\n",
    "\n",
    "सर्वसाधारण Silhouette पद्धत *k* च्या वेगवेगळ्या मूल्यांसाठी निरीक्षणांचे सरासरी Silhouette मोजते. उच्च सरासरी Silhouette स्कोअर चांगल्या क्लस्टरिंगचे संकेत देतो.\n",
    "\n",
    "`silhouette` फंक्शनचा उपयोग क्लस्टर पॅकेजमध्ये सरासरी Silhouette रुंदी मोजण्यासाठी केला जातो.\n",
    "\n",
    "> Silhouette कोणत्याही [distance](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 पर्यंत), आणि **Silhouette स्कोअर** सारख्या क्लस्टरिंग मेट्रिक्सचे मूल्यांकन करणे.\n",
    "\n",
    "चला *k* च्या वेगवेगळ्या मूल्यांसाठी क्लस्टरिंग अल्गोरिदमची गणना करून आणि **Within Cluster Sum of Squares** (WCSS) चे मूल्यांकन करून आदर्श क्लस्टर्सची संख्या निश्चित करूया. एकूण Within-Cluster Sum of Squares (WCSS) क्लस्टरिंगची सघनता मोजते आणि ते शक्य तितके कमी असावे अशी आपली इच्छा आहे, कारण कमी मूल्ये सूचित करतात की डेटा पॉइंट्स एकमेकांच्या जवळ आहेत.\n",
    "\n",
    "चला `k` च्या वेगवेगळ्या निवडींचा, 1 ते 10 पर्यंत, या क्लस्टरिंगवर होणारा परिणाम पाहूया.\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 मध्ये मोठी घट (म्हणजे अधिक *घनता*) दिसते जेव्हा क्लस्टर्सची संख्या एकापासून दोनपर्यंत वाढते, आणि दोन ते तीन क्लस्टर्सपर्यंत आणखी एक लक्षणीय घट दिसते. त्यानंतर, घट कमी ठळक होते, ज्यामुळे चार्टमध्ये सुमारे तीन क्लस्टर्सवर एक `elbow` 💪 तयार होते. हे सूचित करते की डेटा पॉइंट्सचे दोन ते तीन चांगल्या प्रकारे वेगळे क्लस्टर्स आहेत.\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 Clustering साठी योग्य नसावा. हा डेटा खूप असंतुलित आहे, फारसा संबंधित नाही आणि स्तंभांच्या मूल्यांमध्ये खूपच फरक असल्यामुळे क्लस्टरिंग चांगल्या प्रकारे होत नाही. खरं तर, तयार होणारे क्लस्टर्स कदाचित आपण वर परिभाषित केलेल्या तीन शैली श्रेणींनी मोठ्या प्रमाणावर प्रभावित किंवा वाकवले जात असतील.\n",
    "\n",
    "तरीही, हा एक चांगला शिकण्याचा अनुभव होता!\n",
    "\n",
    "Scikit-learn च्या दस्तऐवजांमध्ये, तुम्ही पाहू शकता की अशा प्रकारच्या मॉडेलमध्ये, जिथे क्लस्टर्स स्पष्टपणे वेगळे नाहीत, 'variance' समस्या असते:\n",
    "\n",
    "<p >\n",
    "   <img src=\"../../images/problems.png\"\n",
    "   width=\"500\"/>\n",
    "   <figcaption>Scikit-learn मधील माहितीपट</figcaption>\n",
    "\n",
    "\n",
    "\n",
    "## **Variance**\n",
    "\n",
    "Variance म्हणजे \"मध्यम मूल्यापासून चौरस फरकांचे सरासरी\" [source](https://www.mathsisfun.com/data/standard-deviation.html). या क्लस्टरिंग समस्येच्या संदर्भात, याचा अर्थ असा आहे की आपल्या डेटासेटमधील संख्या मध्यम मूल्यापासून खूपच दूर जात आहेत.\n",
    "\n",
    "✅ ही समस्या सुधारण्यासाठी तुम्ही काय करू शकता याचा विचार करण्यासाठी हा एक उत्तम क्षण आहे. डेटा थोडा अधिक बदलावा का? वेगळे स्तंभ वापरावे का? वेगळा अल्गोरिदम वापरावा का? सूचक: तुमचा डेटा [स्केल करा](https://www.mygreatlearning.com/blog/learning-data-science-with-k-means-clustering/) आणि इतर स्तंभ तपासा.\n",
    "\n",
    "> '[variance calculator](https://www.calculatorsoup.com/calculators/statistics/variance-calculator.php)' वापरून संकल्पना अधिक चांगल्या प्रकारे समजून घ्या.\n",
    "\n",
    "------------------------------------------------------------------------\n",
    "\n",
    "## **🚀Challenge**\n",
    "\n",
    "या नोटबुकसह काही वेळ घालवा आणि पॅरामीटर्स बदलून पहा. डेटा अधिक स्वच्छ करून (उदाहरणार्थ, बाह्य घटक काढून) मॉडेलची अचूकता सुधारू शकता का? तुम्ही दिलेल्या डेटा नमुन्यांना अधिक वजन देण्यासाठी वजन वापरू शकता. चांगले क्लस्टर्स तयार करण्यासाठी आणखी काय करू शकता?\n",
    "\n",
    "सूचक: तुमचा डेटा स्केल करण्याचा प्रयत्न करा. नोटबुकमध्ये टिप्पणी केलेला कोड आहे जो मानक स्केलिंग जोडतो, ज्यामुळे डेटा स्तंभ श्रेणीच्या बाबतीत एकमेकांशी अधिक जवळीक साधतात. तुम्हाला असे आढळेल की जरी सिल्हूट स्कोअर कमी होतो, तरीही एल्बो ग्राफमधील 'किंक' गुळगुळीत होतो. कारण डेटा स्केल न केल्याने कमी variance असलेल्या डेटाला अधिक वजन मिळते. या समस्येवर अधिक वाचा [येथे](https://stats.stackexchange.com/questions/21222/are-mean-normalization-and-feature-scaling-needed-for-k-means-clustering/21226#21226).\n",
    "\n",
    "## [**Post-lecture quiz**](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/30/)\n",
    "\n",
    "## **Review & Self Study**\n",
    "\n",
    "-   K-Means Simulator [जसे की हा](https://user.ceng.metu.edu.tr/~akifakkus/courses/ceng574/k-means/) पाहा. तुम्ही या साधनाचा वापर नमुना डेटा पॉइंट्स व्हिज्युअलाइझ करण्यासाठी आणि त्याचे सेंटरॉइड्स ठरवण्यासाठी करू शकता. तुम्ही डेटाच्या randomness, क्लस्टर्सची संख्या आणि सेंटरॉइड्सची संख्या संपादित करू शकता. यामुळे तुम्हाला डेटा कसा गटबद्ध करता येतो याची कल्पना मिळते का?\n",
    "\n",
    "-   [Stanford मधील K-Means वरचा हा हँडआउट](https://stanford.edu/~cpiech/cs221/handouts/kmeans.html) देखील पाहा.\n",
    "\n",
    "तुमच्या नव्याने मिळवलेल्या क्लस्टरिंग कौशल्यांचा वापर अशा डेटासेट्सवर करायचा आहे का जे K-Means क्लस्टरिंगसाठी योग्य आहेत? कृपया पाहा:\n",
    "\n",
    "-   [Train and Evaluate Clustering Models](https://rpubs.com/eR_ic/clustering) Tidymodels आणि मित्रांसह\n",
    "\n",
    "-   [K-means Cluster Analysis](https://uc-r.github.io/kmeans_clustering), UC Business Analytics R Programming Guide\n",
    "\n",
    "- [K-means clustering with tidy data principles](https://www.tidymodels.org/learn/statistics/k-means/)\n",
    "\n",
    "## **Assignment**\n",
    "\n",
    "[वेगवेगळ्या क्लस्टरिंग पद्धती वापरून पहा](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/2-K-Means/assignment.md)\n",
    "\n",
    "## धन्यवाद:\n",
    "\n",
    "[Jen Looper](https://www.twitter.com/jenlooper) यांना या मॉड्यूलची मूळ Python आवृत्ती तयार केल्याबद्दल ♥️\n",
    "\n",
    "[`Allison Horst`](https://twitter.com/allison_horst/) यांना R अधिक स्वागतार्ह आणि आकर्षक बनवणाऱ्या अप्रतिम चित्रण तयार केल्याबद्दल. तिच्या [gallery](https://www.google.com/url?q=https://github.com/allisonhorst/stats-illustrations&sa=D&source=editors&ust=1626380772530000&usg=AOvVaw3zcfyCizFQZpkSLzxiiQEM) मध्ये अधिक चित्रण शोधा.\n",
    "\n",
    "शिकण्याचा आनंद घ्या,\n",
    "\n",
    "[Eric](https://twitter.com/ericntay), Gold Microsoft Learn Student Ambassador.\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"
   ]
  }
 ]
}