R के साथ K-Nearest Neighbors (KNN) वर्गीकरण ट्यूटोरियल

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

इस ट्यूटोरियल में, हम K-Nearest Neighbors के बारे में जानेंगे, यह कैसे काम करता है, और इसके कुछ फायदे और नुकसान की समीक्षा करेंगे। आगे चलकर, हम KNN वर्गीकरण मॉडल को आसानी से लागू करने के लिए 'class' और 'caret' R पैकेजों का उपयोग करेंगे।

K-Nearest Neighbors क्या है?

K-Nearest Neighbors (KNN) एक सुपरवाइज़्ड मशीन लर्निंग मॉडल है जिसका उपयोग रिग्रेशन और क्लासिफिकेशन दोनों कार्यों के लिए किया जा सकता है। यह एल्गोरिद्म नॉन-पैरामीट्रिक है, यानी यह डेटा के अंतर्निहित वितरण के बारे में कोई धारणा नहीं बनाता।

KNN एल्गोरिद्म, प्रशिक्षण डेटासेट के फीचर स्पेस में नए डेटा बिंदु के सबसे नज़दीकी पड़ोसियों के लेबल देखकर टेस्ट डेटासेट के लेबल की भविष्यवाणी करता है। “K” सबसे महत्वपूर्ण हाइपरपैरामीटर है जिसे मॉडल के प्रदर्शन को अनुकूलित करने के लिए ट्यून किया जा सकता है।

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

KNN एल्गोरिद्म का उपयोग ई-कॉमर्स रिकमेंडेशन इंजन, इमेज रिकॉग्निशन, फ्रॉड डिटेक्शन, टेक्स्ट क्लासिफिकेशन, एनॉमली डिटेक्शन आदि में किया जाता है। इस ट्यूटोरियल में, हम KNN एल्गोरिद्म का उपयोग एक लोन अप्रूवल सिस्टम के लिए करेंगे।

यदि आप उलझन में हैं और नहीं जानते कि अपनी डेटा साइंस यात्रा कैसे शुरू करें, तो Data Scientist Professional with R करियर ट्रैक लें और डेटा साइंस में सफल करियर के लिए खुद को तैयार करें। यह स्किल ट्रैक आपको R प्रोग्रामिंग, डेटा इनजेशन, डेटा क्लीनिंग, डेटा मैनिपुलेशन, डेटा विज़ुअलाइज़ेशन, मशीन लर्निंग, हाइपोथेसिस टेस्ट, प्रायोगिक डिजाइन, SQL, और Git में निपुण बनने में मदद करेगा।

K-Nearest Neighbors Classification कैसे काम करता है?

KNN वर्गीकरण एल्गोरिद्म, किसी नए डेटा बिंदु के लिए प्रशिक्षण डेटासेट में K पड़ोसियों (सबसे नज़दीकी डेटा बिंदुओं) को ढूंढकर काम करता है। फिर, यह नए डेटा बिंदु को उसके पड़ोसियों में बहुमत वाले वर्ग का लेबल सौंप देता है।

आइए एल्गोरिद्म को कई हिस्सों में विभाजित करें।

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

K सबसे नज़दीकी पड़ोसियों की पहचान करने के बाद, एल्गोरिद्म उन पड़ोसियों में बहुमत वाले वर्ग का लेबल नए डेटा बिंदु को दे देता है। उदाहरण के लिए, यदि दो लेबल “नीला” और एक लेबल “लाल” है, तो एल्गोरिद्म नए डेटा बिंदु को “नीला” लेबल सौंपेगा।

Gif: eunsukim.me से

सारांश:

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

“K” का मान उपयोगकर्ता देता है, और इसका उपयोग एल्गोरिद्म के प्रदर्शन को अनुकूलित करने के लिए किया जा सकता है। छोटा K ओवरफिटिंग की ओर ले जा सकता है, और बड़ा K अंडरफिटिंग की ओर। इसलिए, ऐसे इष्टतम मान खोजना महत्वपूर्ण है जो स्थिरता और सर्वोत्तम फिट प्रदान करें।

R में KNN का कार्यान्वयन

इस खंड में, हम Loan Data का उपयोग करेंगे और class पैकेज के माध्यम से KNN वर्गीकरण को प्रशिक्षित करेंगे। डेटासेट में 10,000 लोन हैं, और हम ग्राहक के डेटा के आधार पर यह पता लगाएंगे कि लोन वापस चुकाया जाएगा या नहीं।

डेटा लोड करना

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

इसके बाद, हम read_csv से डेटासेट लोड करेंगे, subset फ़ंक्शन का उपयोग करके डेटा फ्रेम से “purpose” कॉलम हटाएँगे, और शीर्ष 3 नमूने प्रदर्शित करेंगे।

suppressPackageStartupMessages(library(tidyverse))

data <- read_csv('data/loans.csv.gz', show_col_types = FALSE)
data <- subset(data, select = -c(purpose))
head(data,3)संचालित द्वारा

ट्रेन और टेस्ट विभाजन

हम डेटासेट को मैन्युअल रूप से विभाजित कर सकते हैं, लेकिन caTools लाइब्रेरी का उपयोग करना अधिक साफ-सुथरा है।

• दोहराने योग्य परिणामों के लिए seed सेट करें।
• sample.split का उपयोग करके 75:25 अनुपात में प्रशिक्षण और परीक्षण डेटासेट के लिए इंडेक्स बनाएँ।
• नीचे दिखाए अनुसार subset का उपयोग करके ट्रेन और टेस्ट डेटासेट बनाएँ।

library(caTools)
set.seed(255)

split = sample.split(data$not_fully_paid, 
                     SplitRatio = 0.75)
train = subset(data, 
                      split == TRUE)
test = subset(data, 
                  split == FALSE)संचालित द्वारा

फीचर स्केलिंग

अब हम प्रशिक्षण और परीक्षण दोनों सेट को स्केल करेंगे। बैकएंड में, फ़ंक्शन (x - mean(x)) / sd(x) का उपयोग करता है। हम केवल फीचर्स को स्केल कर रहे हैं और टेस्टिंग व ट्रेनिंग दोनों सेट से टार्गेट लेबल हटा रहे हैं।

train_scaled = scale(train[-13])
test_scaled = scale(test[-13])संचालित द्वारा

KNN क्लासिफायर का प्रशिक्षण और भविष्यवाणी

class लाइब्रेरी KNN वर्गीकरण को प्रशिक्षित करने के लिए काफी लोकप्रिय है। यह सरल और तेज़ है। हम स्केल किए गए ट्रेन और टेस्ट डेटासेट, टार्गेट कॉलम, और “k” हाइपरपैरामीटर प्रदान करेंगे।

library(class)
test_pred <- knn(
                 train = train_scaled, 
                 test = test_scaled,
                 cl = train$not_fully_paid, 
                 k=10
                 )संचालित द्वारा

मॉडल मूल्यांकन

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

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

actual <- test$not_fully_paid

cm <- table(actual,test_pred)
cmसंचालित द्वारा

     test_pred
actual    0    1
     0 1988   23
     1  373   10संचालित द्वारा

हम कंफ्यूज़न मैट्रिक्स से ट्रू पॉजिटिव मूल्यों का योग लेकर और उन्हें टार्गेट कॉलम की कुल लंबाई से भाग देकर सटीकता (accuracy) की गणना कर सकते हैं।

जैसा कि हम देखते हैं, साधारण मॉडल पर हमारी सटीकता अच्छी है। हम “K” हाइपरपैरामीटर को ट्यून करके और डेटासेट को संतुलित करके इस सटीकता में सुधार कर सकते हैं।

accuracy <- sum(diag(cm))/length(actual)
sprintf("Accuracy: %.2f%%", accuracy*100)संचालित द्वारा

'Accuracy: 83.46%'संचालित द्वारा

caret का उपयोग करके R में KNN वर्गीकरण

इस खंड में, हम हर चीज़ के लिए caret का उपयोग करेंगे। caret एक R पैकेज है जो मशीन लर्निंग मॉडल बनाने और उनका मूल्यांकन करने के लिए इस्तेमाल होता है। यह प्रमुख मशीन लर्निंग एल्गोरिद्म के लिए एक इंटरफ़ेस प्रदान करता है।

हम इसका उपयोग डेटासेट को विभाजित और पूर्व-संसाधित करने, हाइपरपैरामीटर ट्यूनिंग करने, और मॉडल को प्रशिक्षित व मूल्यांकित करने के लिए करेंगे।

ट्रेन और टेस्ट विभाजन

हम caret पैकेज इम्पोर्ट करेंगे और पुनरुत्पादनशीलता के लिए seed सेट करेंगे। उसके बाद, हम टार्गेट वेरिएबल को integer से factor में बदलेंगे। अंत में, हम createDataPartition का उपयोग करके 80:20 अनुपात में डेटासेट को ट्रेन और टेस्ट सेट में विभाजित करेंगे।

suppressPackageStartupMessages(library(caret))
set.seed(255)

data$not_fully_paid <- factor(data$not_fully_paid, levels = c(0, 1))

trainIndex <- createDataPartition(data$not_fully_paid, 
								  times=1, 
								  p = .8, 
								  list = FALSE)
train <- data[trainIndex, ]
test <- data[-trainIndex, ]संचालित द्वारा

डेटा प्रीप्रोसेसिंग

फिर हम preProcess फ़ंक्शन का उपयोग करके प्रशिक्षण और परीक्षण दोनों सेट को स्केल करेंगे।

preProcValues <- preProcess(train, method = c("center", "scale"))
trainTransformed <- predict(preProcValues, train)
testTransformed <- predict(preProcValues, test)संचालित द्वारा

मॉडल ट्यूनिंग

KNN मॉडल को प्रशिक्षित करने से पहले, हमें ट्रेनिंग फ़ंक्शन का उपयोग करके “K” का इष्टतम मान खोजना होगा। train फ़ंक्शन को एक फ़ॉर्मूला, स्केल किया हुआ ट्रेनिंग डेटासेट, मॉडल का नाम, ट्रेन कंट्रोल मेथड (क्रॉस-वैलिडेशन), और हाइपरपैरामीटर की सूची चाहिए। हम वहाँ मॉडल के प्रदर्शन की जाँच करेंगे जहाँ “K” 3, 5, और 7 है।

knnModel <- train(
		     not_fully_paid ~ ., 
		     data = trainTransformed, 
	            method = "knn", 
		     trControl = trainControl(method = "cv"), 
		     tuneGrid = data.frame(k = c(3,5,7))
		    )संचालित द्वारा

सर्वश्रेष्ठ मॉडल का प्रशिक्षण

“K” का सर्वोत्तम मान मिलने के बाद, हम स्केल किए गए ट्रेनिंग डेटासेट के साथ KNN वर्गीकरण मॉडल को प्रशिक्षित करेंगे।

best_model<- knn3(
                  not_fully_paid ~ .,
                  data = trainTransformed,
                  k = knnModel$bestTune$k
                 )संचालित द्वारा

मॉडल मूल्यांकन

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

predictions <- predict(best_model, testTransformed,type = "class")
# Calculate confusion matrix
cm <- confusionMatrix(predictions, testTransformed$not_fully_paid)
cmसंचालित द्वारा

नतीजे के रूप में, हमें कंफ्यूज़न मैट्रिक्स, मॉडल सटीकता, P-Value, मॉडल सेंसिटिविटी, और अन्य महत्वपूर्ण मीट्रिक्स मिलते हैं, जो हमें मॉडल की स्थिरता और प्रदर्शन निर्धारित करने में मदद करेंगे।

जैसा कि हम देख सकते हैं, मॉडल ने “Neg Pred Value” पर काफ़ी खराब प्रदर्शन किया है, जो कि एक अल्पसंख्यक वर्ग है, और हमारी संतुलित सटीकता 51% है। हमें सिक्का उछालने पर भी इसी तरह का परिणाम मिल सकता है।

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

Confusion Matrix and Statistics

          Reference
Prediction    0    1
         0 1570  288
         1   39   18
                                          
               Accuracy : 0.8292          
                 95% CI : (0.8116, 0.8458)
    No Information Rate : 0.8402          
    P-Value [Acc > NIR] : 0.9091          
                                          
                  Kappa : 0.0516          
                                          
 Mcnemar's Test P-Value : <2e-16          
                                          
            Sensitivity : 0.97576         
            Specificity : 0.05882         
         Pos Pred Value : 0.84499         
         Neg Pred Value : 0.31579         
             Prevalence : 0.84021         
         Detection Rate : 0.81984         
   Detection Prevalence : 0.97023         
      Balanced Accuracy : 0.51729         
                                          
       'Positive' Class : 0संचालित द्वारा

हम अपने परिणाम को एक डेटा फ्रेम के रूप में दिखाकर भी सरल बना सकते हैं।

data.frame(Accuracy = cm$overall["Accuracy"],
           Sensitivity = cm$byClass["Sensitivity"],
           Specificity = cm$byClass["Specificity"])संचालित द्वारा

यदि आप Python पसंद करते हैं और यह सीखना चाहते हैं कि KNN वर्गीकरण कैसे करें, तो हमारे K-Nearest Neighbors (KNN) Classification with scikit-learn ट्यूटोरियल को पढ़ें, ताकि उदाहरणों के साथ KNN की अवधारणाएँ और वर्कफ़्लो समझ सकें।

KNN के उपयोग के फायदे और नुकसान

फायदे

1. समझने और लागू करने के लिए यह एक सरल एल्गोरिद्म है।
2. यह बहुमुखी है और रिग्रेशन तथा क्लासिफिकेशन दोनों कार्यों के लिए उपयोग किया जा सकता है।
3. यह व्याख्येय परिणाम देता है जिन्हें विज़ुअलाइज़ और समझा जा सकता है, क्योंकि भविष्यवाणी की गई श्रेणी प्रशिक्षण डेटा में निकटतम पड़ोसियों के लेबल पर आधारित होती है।
4. KNN श्रेणियों के बीच निर्णय सीमा के बारे में धारणाएँ नहीं बनाता, और यह विशेषता इसे फीचर्स के बीच गैर-रेखीय संबंधों को पकड़ने में सक्षम बनाती है।
5. एल्गोरिद्म डेटा के वितरण के बारे में धारणाएँ नहीं बनाता, जिससे यह व्यापक समस्याओं के लिए उपयुक्त हो जाता है।
6. KNN मॉडल नहीं बनाता; यह प्रशिक्षण डेटा संग्रहीत करता है और भविष्यवाणी के लिए उसका उपयोग करता है।

नुकसान

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

निष्कर्ष

इस ट्यूटोरियल में, हमने R के साथ K-Nearest Neighbors (KNN) वर्गीकरण का उपयोग करना सीखा। हमने KNN की बुनियादी अवधारणा और इसका कार्यविधि कवर किया। साथ ही, हमने class और caret दो लाइब्रेरीज़ के बारे में जाना, जिनसे वास्तविक डेटासेट पर KNN वर्गीकरण मॉडल को प्रशिक्षित और मूल्यांकित किया जा सकता है।

Supervised Learning in R: Classification पाठ्यक्रम लें ताकि आप R प्रोग्रामिंग के साथ अन्य सुपरवाइज़्ड मशीन लर्निंग एल्गोरिद्म के बारे में जान सकें। आप Naive Bayes, Logistic Regression, और Classification Trees को उदाहरणों और कोड अभ्यासों के साथ सीखेंगे।

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

यह समझना आवश्यक है कि KNN एल्गोरिद्म परफेक्ट नहीं है; इसके कुछ नुक़सान भी हैं, और इसे अपना प्राथमिक मॉडल चुनने से पहले हमें कई बातों पर विचार करना चाहिए।