कश्मीर साधन Clusterउदाहरण के साथ R में

एचएमबी क्या है? Cluster विश्लेषण?

Cluster विश्लेषण का हिस्सा है अप्रकाशित शिक्षाक्लस्टर डेटा का एक समूह है जो समान विशेषताओं को साझा करता है। हम कह सकते हैं, क्लस्टरिंग विश्लेषण भविष्यवाणी से ज़्यादा खोज के बारे में है। मशीन डेटा में समानता की खोज करती है। उदाहरण के लिए, आप निम्न एप्लिकेशन के लिए क्लस्टर विश्लेषण का उपयोग कर सकते हैं:

• ग्राहक विभाजन: ग्राहकों के समूहों के बीच समानता की तलाश करता है
• स्टॉक मार्केट क्लस्टरिंग: प्रदर्शन के आधार पर स्टॉक को समूहीकृत करना
• समान मान वाले प्रेक्षणों को समूहीकृत करके डेटासेट की विमाशीलता कम करें

Clusterविश्लेषण को क्रियान्वित करना अधिक कठिन नहीं है तथा यह व्यवसाय के लिए सार्थक और कार्यान्वयन योग्य भी है।

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

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

निम्नलिखित ग्राफ में, आप कुल व्यय और ग्राहकों की आयु दर्शा रहे हैं।

library(ggplot2)
df <- data.frame(age = c(18, 21, 22, 24, 26, 26, 27, 30, 31, 35, 39, 40, 41, 42, 44, 46, 47, 48, 49, 54),
    spend = c(10, 11, 22, 15, 12, 13, 14, 33, 39, 37, 44, 27, 29, 20, 28, 21, 30, 31, 23, 24)
)
ggplot(df, aes(x = age, y = spend)) +
    geom_point()

इस बिंदु पर एक पैटर्न दिखाई देता है

1. नीचे बाईं ओर आप कम क्रय शक्ति वाले युवा लोगों को देख सकते हैं
2. उच्च-मध्यम वर्ग में वे लोग शामिल हैं जिनके पास ऐसी नौकरी है जिसे वे वहन कर सकते हैं और अधिक खर्च करते हैं
3. अंत में, कम बजट वाले वृद्ध लोग।

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

इस ट्यूटोरियल में, आप सीखेंगे कि इसका उपयोग कैसे करें k-साधन कलन विधि।

के-मीन्स एल्गोरिथम

के-मीन, बिना किसी संदेह के, सबसे लोकप्रिय क्लस्टरिंग विधि है। शोधकर्ताओं ने दशकों पहले इस एल्गोरिथ्म को जारी किया था, और के-मीन में बहुत सारे सुधार किए गए हैं।

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

एल्गोरिथ्म इस प्रकार काम करता है:

• चरण 1: फ़ीचर योजना में समूहों को यादृच्छिक रूप से चुनें
• चरण 2: क्लस्टर केंद्र और विभिन्न अवलोकनों के बीच की दूरी को न्यूनतम करें (केन्द्रक) इसके परिणामस्वरूप अवलोकन वाले समूह बनते हैं
• चरण १: Shift किसी समूह के भीतर निर्देशांकों के माध्य का प्रारंभिक केन्द्रक।
• चरण 4: नए केन्द्रक के अनुसार दूरी कम करें। नई सीमाएँ बनाई जाती हैं। इस प्रकार, अवलोकन एक समूह से दूसरे समूह में चले जाएँगे
• तब तक दोहराएं जब तक कोई अवलोकन समूह न बदल जाए

K-मीन्स आमतौर पर फीचर और फीचर के बीच यूक्लिडियन दूरी लेता है:

मैनहट्टन दूरी या मिनलोव्स्की दूरी जैसे विभिन्न उपाय उपलब्ध हैं। ध्यान दें कि, जब भी आप एल्गोरिथ्म चलाते हैं, K-mean अलग-अलग समूह लौटाता है। याद रखें कि पहले प्रारंभिक अनुमान यादृच्छिक होते हैं और तब तक दूरियों की गणना करते हैं जब तक कि एल्गोरिथ्म समूहों के भीतर एकरूपता तक नहीं पहुँच जाता। यानी, k-mean पहली पसंद के प्रति बहुत संवेदनशील है, और जब तक अवलोकन और समूहों की संख्या कम न हो, तब तक समान क्लस्टरिंग प्राप्त करना लगभग असंभव है।

क्लस्टरों की संख्या चुनें

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

क्लस्टर की संख्या डेटा सेट की प्रकृति, उद्योग, व्यवसाय आदि पर निर्भर करती है। हालाँकि, क्लस्टर की उचित संख्या चुनने के लिए एक सामान्य नियम है:

डेटासेट में अवलोकन की संख्या के बराबर है।

सामान्यतः, व्यवसाय की आवश्यकता के अनुरूप सर्वोत्तम मूल्य की खोज में समय व्यतीत करना दिलचस्प होता है।

हम अपने क्लस्टरिंग विश्लेषण के लिए पर्सनल कंप्यूटर की कीमतों के डेटासेट का उपयोग करेंगे। इस डेटासेट में 6259 अवलोकन और 10 विशेषताएं हैं। डेटासेट में 1993 से 1995 तक अमेरिका में 486 पर्सनल कंप्यूटर की कीमतों का अवलोकन किया गया है। चर हैं कीमत, गति, रैम, स्क्रीन, सीडी और अन्य।

आप निम्न प्रकार आगे बढ़ेंगे:

• आयात आंकड़ा
• मॉडल को प्रशिक्षित करें
• मॉडल का मूल्यांकन करें

आयात आंकड़ा

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

library(dplyr)
PATH <-"https://raw.githubusercontent.com/guru99-edu/R-Programming/master/computers.csv"
df <- read.csv(PATH) %>%
select(-c(X, cd, multi, premium))
glimpse(df)

उत्पादन

## Observations: 6, 259
## Variables: 7
## $ price < int > 1499, 1795, 1595, 1849, 3295, 3695, 1720, 1995, 2225, 2...
##$ speed < int > 25, 33, 25, 25, 33, 66, 25, 50, 50, 50, 33, 66, 50, 25, ...
##$ hd < int > 80, 85, 170, 170, 340, 340, 170, 85, 210, 210, 170, 210...
##$ ram < int > 4, 2, 4, 8, 16, 16, 4, 2, 8, 4, 8, 8, 4, 8, 8, 4, 2, 4, ...
##$ screen < int > 14, 14, 15, 14, 14, 14, 14, 14, 14, 15, 15, 14, 14, 14, ...
##$ ads < int > 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, ...
## $ trend  <int> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1...

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

summary(df)

आउटपुट:

##      price          speed              hd              ram        
##  Min.   : 949   Min.   : 25.00   Min.   :  80.0   Min.   : 2.000  
##  1st Qu.:1794   1st Qu.: 33.00   1st Qu.: 214.0   1st Qu.: 4.000  `
##  Median :2144   Median : 50.00   Median : 340.0   Median : 8.000  
##  Mean   :2220   Mean   : 52.01   Mean   : 416.6   Mean   : 8.287  
##  3rd Qu.:2595   3rd Qu.: 66.00   3rd Qu.: 528.0   3rd Qu.: 8.000  
##  Max.   :5399   Max.   :100.00   Max.   :2100.0   Max.   :32.000  
##      screen           ads            trend      
##  Min.   :14.00   Min.   : 39.0   Min.   : 1.00  
##  1st Qu.:14.00   1st Qu.:162.5   1st Qu.:10.00  
##  Median :14.00   Median :246.0   Median :16.00  
##  Mean   :14.61   Mean   :221.3   Mean   :15.93  
##  3rd Qu.:15.00   3rd Qu.:275.0   3rd Qu.:21.50  
##  Max.   :17.00   Max.   :339.0   Max.   :35.00

आप dplyr लाइब्रेरी के scale() फ़ंक्शन के साथ चरों को पुनः स्केल करते हैं। परिवर्तन आउटलायर्स के प्रभाव को कम करता है और माध्य के विरुद्ध एकमात्र अवलोकन की तुलना करने की अनुमति देता है। यदि कोई मानकीकृत मान (या z- स्कोर) उच्च है, तो आप आश्वस्त हो सकते हैं कि यह अवलोकन वास्तव में माध्य से ऊपर है (एक बड़ा z-स्कोर यह दर्शाता है कि यह बिंदु मानक विचलन के संदर्भ में माध्य से बहुत दूर है। दो का z-स्कोर यह दर्शाता है कि मान माध्य से 2 मानक विचलन दूर है। ध्यान दें, z-स्कोर एक गाऊसी वितरण का अनुसरण करता है और माध्य के चारों ओर सममित होता है।

rescale_df <- df % > %
mutate(price_scal = scale(price),
    hd_scal = scale(hd),
    ram_scal = scale(ram),
    screen_scal = scale(screen),
    ads_scal = scale(ads),
    trend_scal = scale(trend)) % > %
select(-c(price, speed, hd, ram, screen, ads, trend))

आर बेस में k मीन एल्गोरिथम चलाने के लिए एक फ़ंक्शन है। k मीन का मूल फ़ंक्शन है:

kmeans(df, k)
arguments:
-df: dataset used to run the algorithm
-k: Number of clusters

मॉडल को प्रशिक्षित करें

चित्र तीन में, आपने विस्तार से बताया कि एल्गोरिदम कैसे काम करता है। आप यी हुई (Rmarkdown के लिए निट के निर्माता भी) द्वारा बनाए गए बेहतरीन पैकेज के साथ प्रत्येक चरण को ग्राफ़िक रूप से देख सकते हैं। पैकेज एनीमेशन कोंडा लाइब्रेरी में उपलब्ध नहीं है। आप पैकेज को install.packages(“animation”) के साथ इंस्टॉल करने के लिए दूसरे तरीके का उपयोग कर सकते हैं। आप जाँच सकते हैं कि पैकेज हमारे एनाकोंडा फ़ोल्डर में इंस्टॉल है या नहीं।

install.packages("animation")

लाइब्रेरी लोड करने के बाद, आप kmeans के बाद .ani जोड़ते हैं और R सभी चरणों को प्लॉट करेगा। उदाहरण के लिए, आप केवल तीन क्लस्टर के साथ rescaled चर hd और ram के साथ एल्गोरिथ्म चलाते हैं।

set.seed(2345)
library(animation)
kmeans.ani(rescale_df[2:3], 3)

कोड स्पष्टीकरण

• kmeans.ani(rescale_df[2:3], 3): rescale_df डेटा सेट के स्तंभ 2 और 3 का चयन करें और k सेट को 3 पर रखकर एल्गोरिथ्म चलाएँ। एनीमेशन प्लॉट करें।

आप एनीमेशन की व्याख्या इस प्रकार कर सकते हैं:

• चरण 1: R यादृच्छिक रूप से तीन बिंदु चुनता है
• चरण 2: यूक्लिडियन दूरी की गणना करें और क्लस्टर बनाएं। आपके पास नीचे बाईं ओर हरे रंग का एक क्लस्टर है, दाईं ओर काले रंग का एक बड़ा क्लस्टर है और उनके बीच में लाल रंग का एक क्लस्टर है।
• चरण 3: केन्द्रक, अर्थात क्लस्टरों का माध्य, की गणना करें
• तब तक दोहराएं जब तक कोई डेटा क्लस्टर न बदल जाए

सात पुनरावृत्तियों के बाद एल्गोरिथ्म अभिसरित हुआ। आप हमारे डेटासेट में पाँच क्लस्टर के साथ k-mean एल्गोरिथ्म चला सकते हैं और इसे pc_cluster कह सकते हैं।

pc_cluster <-kmeans(rescale_df, 5)

• सूची pc_cluster में सात दिलचस्प तत्व शामिल हैं:
• pc_cluster$cluster: प्रत्येक अवलोकन के क्लस्टर को इंगित करता है
• pc_cluster$centers: क्लस्टर केंद्र
• pc_cluster$totss: वर्गों का कुल योग
• pc_cluster$withinss: वर्ग के योग के भीतर। घटकों की वापसी की संख्या `k` के बराबर है
• pc_cluster$tot.withinss: भीतर का योग
• pc_clusterbetweenss: वर्ग का कुल योग घटा वर्ग के भीतर का योग
• pc_cluster$size: प्रत्येक क्लस्टर के भीतर अवलोकन की संख्या

आप क्लस्टर k की इष्टतम संख्या की गणना करने के लिए वर्ग के भीतर के योग (यानी tot.withinss) का उपयोग करेंगे। k का पता लगाना वास्तव में एक महत्वपूर्ण कार्य है।

इष्टतम के

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

इस ट्यूटोरियल में, हम विषमता माप का उपयोग करके इस बिंदु को ढूंढते हैं। क्लस्टर के भीतर वर्गों का कुल योग kmean() द्वारा लौटाई गई सूची में tot.withinss है।

आप कोहनी ग्राफ का निर्माण कर सकते हैं और इष्टतम k को निम्न प्रकार से ज्ञात कर सकते हैं:

• चरण 1: क्लस्टरों के भीतर कुल वर्गों के योग की गणना करने के लिए एक फ़ंक्शन का निर्माण करें
• चरण 2: एल्गोरिथ्म को बार-बार चलाएँ
• चरण 3: एल्गोरिथम के परिणामों के साथ एक डेटा फ़्रेम बनाएँ
• चरण 4: परिणाम प्लॉट करें

चरण 1) क्लस्टरों के भीतर कुल वर्गों के योग की गणना करने के लिए एक फ़ंक्शन का निर्माण करें

आप वह फ़ंक्शन बनाते हैं जो k-मीन एल्गोरिथ्म को चलाता है और कुल को क्लस्टर के भीतर संग्रहीत करता है वर्गों का योग

kmean_withinss <- function(k) {
    cluster <- kmeans(rescale_df, k)
    return (cluster$tot.withinss)
}

कोड स्पष्टीकरण

• फ़ंक्शन(k): फ़ंक्शन में तर्कों की संख्या निर्धारित करें
• kmeans(rescale_df, k): एल्गोरिथ्म को k बार चलाएँ
• return(cluster$tot.withinss): क्लस्टर के भीतर वर्गों का कुल योग संग्रहित करें

आप फ़ंक्शन का परीक्षण बराबर 2 के साथ कर सकते हैं।

आउटपुट:

## Try with 2 cluster

kmean_withinss(2)

आउटपुट:

## [1] 27087.07

चरण 2) एल्गोरिथ्म को n बार चलाएँ

आप k की सीमा पर एल्गोरिथ्म चलाने के लिए sapply() फ़ंक्शन का उपयोग करेंगे। यह तकनीक लूप बनाने और मान संग्रहीत करने से ज़्यादा तेज़ है।

# Set maximum cluster 
max_k <-20 
# Run algorithm over a range of k 
wss <- sapply(2:max_k, kmean_withinss)

कोड स्पष्टीकरण

• max_k <-20: अधिकतम संख्या 20 पर सेट करें
• sapply(2:max_k, kmean_withinss): फ़ंक्शन kmean_withinss() को 2:max_k, अर्थात 2 से 20 तक की सीमा पर चलाएँ।

चरण 3) एल्गोरिथ्म के परिणामों के साथ एक डेटा फ़्रेम बनाएँ

हमारे फ़ंक्शन के निर्माण और परीक्षण के बाद, आप k-mean एल्गोरिदम को 2 से 20 तक की सीमा में चला सकते हैं, tot.withinss मानों को संग्रहीत कर सकते हैं।

# Create a data frame to plot the graph
elbow <-data.frame(2:max_k, wss)

कोड स्पष्टीकरण

• data.frame(2:max_k, wss): wss में संग्रहीत एल्गोरिथ्म के आउटपुट के साथ एक डेटा फ़्रेम बनाएँ

चरण 4) परिणाम प्लॉट करें

आप ग्राफ बनाकर यह कल्पना करते हैं कि कोहनी बिंदु कहां है

# Plot the graph with gglop
ggplot(elbow, aes(x = X2.max_k, y = wss)) +
    geom_point() +
    geom_line() +
    scale_x_continuous(breaks = seq(1, 20, by = 1))

ग्राफ से आप देख सकते हैं कि इष्टतम k सात है, जहां वक्र में घटता हुआ प्रतिफल मिलना शुरू हो जाता है।

एक बार जब आपको इष्टतम k मिल जाता है, तो आप k को 7 के बराबर रखते हुए एल्गोरिथ्म को पुनः चलाते हैं और क्लस्टरों का मूल्यांकन करते हैं।

क्लस्टर की जांच

pc_cluster_2 <-kmeans(rescale_df, 7)

जैसा कि पहले बताया गया है, आप kmean() द्वारा लौटाई गई सूची में शेष रोचक जानकारी तक पहुँच सकते हैं।

pc_cluster_2$cluster
pc_cluster_2$centers
pc_cluster_2$size

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

पूर्व मूल्यांकन के रूप में, आप क्लस्टरों के आकार की जांच कर सकते हैं।

pc_cluster_2$size

आउटपुट:

## [1] 608 1596 1231  580 1003  699  542

पहला क्लस्टर 608 अवलोकनों से बना है, जबकि सबसे छोटे क्लस्टर, नंबर 4 में केवल 580 कंप्यूटर हैं। क्लस्टरों के बीच समरूपता होना अच्छा हो सकता है, अगर ऐसा नहीं है, तो कम डेटा तैयार करने की आवश्यकता हो सकती है।

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

center <-pc_cluster_2$centers
center

आउटपुट:

##   price_scal    hd_scal     ram_scal screen_scal   ads_scal trend_scal
## 1 -0.6372457 -0.7097995 -0.691520682  -0.4401632  0.6780366 -0.3379751
## 2 -0.1323863  0.6299541  0.004786730   2.6419582 -0.8894946  1.2673184
## 3  0.8745816  0.2574164  0.513105797  -0.2003237  0.6734261 -0.3300536
## 4  1.0912296 -0.2401936  0.006526723   2.6419582  0.4704301 -0.4132057
## 5 -0.8155183  0.2814882 -0.307621003  -0.3205176 -0.9052979  1.2177279
## 6  0.8830191  2.1019454  2.168706085   0.4492922 -0.9035248  1.2069855
## 7  0.2215678 -0.7132577 -0.318050275  -0.3878782 -1.3206229 -1.5490909

आप श्रेणियों के बीच अंतर को उजागर करने में हमारी सहायता के लिए ggplot के साथ हीट मैप बना सकते हैं।

ggplot के डिफ़ॉल्ट रंगों को RColorBrewer लाइब्रेरी से बदलना होगा। आप conda का उपयोग कर सकते हैं पुस्तकालय और टर्मिनल में लॉन्च करने के लिए कोड:

conda इंस्टॉल -cr r-rcolorbrewer

हीट मैप बनाने के लिए, आप तीन चरणों में आगे बढ़ते हैं:

• केंद्र के मानों के साथ एक डेटा फ़्रेम बनाएँ और क्लस्टर की संख्या के साथ एक चर बनाएँ
• tidyr लाइब्रेरी के gather() फ़ंक्शन के साथ डेटा को पुनः आकार दें। आप डेटा को वाइड से लॉन्ग में बदलना चाहते हैं।
• रंगों के साथ रंगों का पैलेट बनाएंRampपैलेट() फ़ंक्शन

चरण 1) डेटा फ़्रेम बनाएँ

आइये रीशेप डेटासेट बनाएं

library(tidyr)

# create dataset with the cluster number

cluster <- c(1: 7)
center_df <- data.frame(cluster, center)

# Reshape the data

center_reshape <- gather(center_df, features, values, price_scal: trend_scal)
head(center_reshape)

आउटपुट:

##   cluster   features     values
## 1       1 price_scal -0.6372457
## 2       2 price_scal -0.1323863
## 3       3 price_scal  0.8745816
## 4       4 price_scal  1.0912296
## 5       5 price_scal -0.8155183
## 6       6 price_scal  0.8830191		

चरण 2) डेटा को नया आकार दें

नीचे दिया गया कोड रंगों का पैलेट बनाता है जिसका उपयोग आप हीट मैप प्लॉट करने के लिए करेंगे।

library(RColorBrewer)
# Create the palette
hm.palette <-colorRampPalette(rev(brewer.pal(10, 'RdYlGn')),space='Lab')

चरण 3) कल्पना करें

आप ग्राफ बनाकर देख सकते हैं कि क्लस्टर कैसे दिखते हैं।

# Plot the heat map
ggplot(data = center_reshape, aes(x = features, y = cluster, fill = values)) +
    scale_y_continuous(breaks = seq(1, 7, by = 1)) +
    geom_tile() +
    coord_equal() +
    scale_fill_gradientn(colours = hm.palette(90)) +
    theme_classic()

सारांश

हम नीचे दी गई तालिका में k-मीन एल्गोरिथ्म को संक्षेप में प्रस्तुत कर सकते हैं

पैकेज	उद्देश्य	समारोह	तर्क
आधार	ट्रेन k-मीन	केमीन्स()	डीएफ, के
	क्लस्टर तक पहुंच	kmeans()$क्लस्टर
	Cluster केन्द्रों	kmeans()$केंद्र
	आकार क्लस्टर	kmeans()$आकार