शुरुआती लोगों के लिए R में मशीन लर्निंग

iris

# Read in `iris` data
iris <- read.csv(url("http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"), 
                 header = FALSE) 

# Print first lines
head(iris)

# Add column names
names(iris) <- c("Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width", "Species")

# Check the result
iris

चरण दो. अपने डेटा को जानें

अब जब आपने Iris डेटा सेट RStudio में लोड कर लिया है, तो आपको यह समझने की कोशिश करनी चाहिए कि आपका डेटा किस बारे में है। सिर्फ देखना या उसके बारे में पढ़ लेना शुरू करने के लिए पर्याप्त नहीं है!

आपको हाथ गंदे करने होंगे: अपने डेटा सेट का अन्वेषण और दृश्यांकन करें और अगर लगे कि डेटा आपकी समझ से परे है, तो थोड़ा और डोमेन ज्ञान भी जुटाएँ।

संभवतः आपके पास आवश्यक डोमेन ज्ञान पहले से होगा, पर याद दिलाने के लिए, सभी फूलों में सेपल और पंखुड़ी (पेटल) होती है। सेपल पंखुड़ियों को ढकता है और आमतौर पर हरा और पत्तेनुमा होता है, जबकि पंखुड़ियाँ रंगीन पत्तियाँ होती हैं। आईरिस फूलों में यह थोड़ा अलग दिखता है, जैसा कि आप इस तस्वीर में देख सकते हैं:

डेटा सेट का आरंभिक अवलोकन

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

दूसरे शब्दों में, आप देखना चाहते हैं कि दो चरों के बीच कोई सह-संबंध (कोरिलेशन) है या नहीं।

आप उदाहरण के लिए ggvis पैकेज से स्कैटरप्लॉट बना सकते हैं।

ध्यान दें कि आपको पहले ggvis पैकेज लोड करना होगा:

# Load in `ggvis`
library(ggvis)

# Iris scatter plot
iris %>% ggvis(~Sepal.Length, ~Sepal.Width, fill = ~Species) %>% layer_points()संचालित द्वारा

आप देखते हैं कि Setosa आईरिस फूलों की सेपल लंबाई और सेपल चौड़ाई के बीच उच्च सह-संबंध है, जबकि Virginica और Versicolor के लिए सह-संबंध कुछ कम है: डेटा बिंदु ग्राफ पर अधिक फैले हुए हैं और Setosa के मामले की तरह कोई क्लस्टर नहीं बनाते।

वह स्कैटर प्लॉट जो पंखुड़ी की लंबाई और चौड़ाई को मैप करता है, भी इसी तरह की कहानी बताता है:

iris %>% ggvis(~Petal.Length, ~Petal.Width, fill = ~Species) %>% layer_points()संचालित द्वारा

आप देखते हैं कि यह ग्राफ Iris डेटा सेट में शामिल सभी विभिन्न प्रजातियों के लिए पंखुड़ी की लंबाई और चौड़ाई के बीच एक सकारात्मक सह-संबंध इंगित करता है। बेशक, यदि आपको इस बारे में पूरी तरह आश्वस्त होना है, तो आपको इस परिकल्पना को थोड़ा और परखना होगा:

# Overall correlation `Petal.Length` and `Petal.Width`
cor(iris$Petal.Length, iris$Petal.Width)

# Return values of `iris` levels 
x=levels(iris$Species)

# Print Setosa correlation matrix
print(x[1])
cor(iris[iris$Species==x[1],1:4])

# Print Versicolor correlation matrix
print(x[2])
cor(iris[iris$Species==x[2],1:4])

# Print Virginica correlation matrix
print(x[3])
cor(iris[iris$Species==x[3],1:4])

आप देखते हैं कि जब आपने तीनों प्रजातियों को मिलाया, तो सह-संबंध थोड़ा अधिक था, बनिस्बत इसके कि आप अलग-अलग प्रजातियों को देखें: समग्र सह-संबंध 0.96 है, जबकि Versicolor के लिए यह 0.79 है। दूसरी ओर, संख्याओं को राउंड करें तो Setosa और Virginica की पंखुड़ी लंबाई और चौड़ाई के सह-संबंध क्रमशः 0.31 और 0.32 हैं।

टिप: क्या आप खास तौर पर ggvis, ग्राफ़ या हिस्टोग्राम के बारे में जिज्ञासु हैं? हमारा हिस्टोग्राम ट्यूटोरियल और/या ggvis कोर्स देखें।

डेटा का एक सामान्य दृश्यात्मक अवलोकन करने के बाद, आप निम्न लिखकर डेटा सेट देख भी सकते हैं

# Return all `iris` data
iris

# Return first 5 lines of `iris`
head(iris)

# Return structure of `iris`
str(iris)

हालाँकि, जैसा कि आप इस कमांड के परिणाम से देखेंगे, यह आपके डेटा सेट का बारीकी से निरीक्षण करने का सबसे अच्छा तरीका नहीं है: डेटा सेट कंसोल में बहुत जगह लेता है, जिससे एक स्पष्ट धारणा बनाना मुश्किल हो जाता है। इसलिए head(iris) या str(iris) चलाकर डेटा सेट देखना बेहतर विचार है।

ध्यान दें कि आखिरी कमांड आपको num डेटा टाइप और Species एट्रिब्यूट के तीन स्तर (जो कि एक फैक्टर है) साफ़-साफ़ अलग बताने में मदद करेगी। यह बहुत सुविधाजनक है, क्योंकि कई R मशीन लर्निंग क्लासिफ़ायर मांगते हैं कि लक्ष्य फीचर फैक्टर के रूप में कोडेड हो।

याद रखें कि R में फैक्टर वेरिएबल्स श्रेणीगत (categorical) वेरिएबल्स का प्रतिनिधित्व करते हैं। इसलिए ये सीमित संख्या के भिन्न मान ही ले सकती हैं।

Species एट्रिब्यूट पर एक त्वरित नज़र आपको बताएगी कि फूलों की प्रजातियों का विभाजन 50-50-50 है। दूसरी ओर, यदि आप Species एट्रिब्यूट के प्रतिशत वितरण को देखना चाहते हैं, तो आप प्रपोर्शन की तालिका मांग सकते हैं:

# Division of `Species`
table(iris$Species) 

# Percentual division of `Species`
round(prop.table(table(iris$Species)) * 100, digits = 1)

ध्यान दें कि round आर्ग्युमेंट पहले आर्ग्युमेंट prop.table(table(iris$Species))*100 के मानों को निर्दिष्ट अंकों तक राउंड करता है, जो यहाँ दशमलव के बाद एक अंक है। आप digits आर्ग्युमेंट का मान बदलकर इसे आसानी से समायोजित कर सकते हैं।

अपने डेटा की गहन समझ

आइए डेटा के इस ऊपरी-स्तर के अवलोकन तक सीमित न रहें! R आपको summary() फ़ंक्शन के साथ और गहराई में जाने का अवसर देता है। यह आपको संख्यात्मक डेटा टाइप्स के लिए न्यूनतम मान, पहला क्वार्टाइल, माध्यिका, औसत, तीसरा क्वार्टाइल और अधिकतम मान देता है। क्लास वेरिएबल के लिए, फैक्टर का काउंट लौटाया जाएगा:

# Summary overview of `iris`
summary(....) 

# Refined summary overview
summary(....[c("Petal.Width", "Sepal.Width")])

जैसा कि आप देखते हैं, मूल कमांड में c() फ़ंक्शन जोड़ा गया है: petal width और sepal width कॉलमों को जोड़कर सिर्फ इन्हीं दो कॉलमों का Iris डेटा सेट पर सारांश मांगा गया है।

चरण तीन. अब आगे कहाँ?

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

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

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

ध्यान दें कि यदि आप KNN का उपयोग रिग्रेशन के लिए करना चाहते हैं, तो आप संख्यात्मक कॉलमों में से किसी एक को लक्ष्य वेरिएबल भी ले सकते हैं।

चरण चार. अपना वर्कस्पेस तैयार करें

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

टिप: आपको किस लर्निंग एल्गोरिद्म का उपयोग करना है इसका अंदाज़ा है, पर किस पैकेज की ज़रूरत होगी यह नहीं? R में उपयोग होने वाले सभी पैकेजों का काफ़ी पूरा अवलोकन आपको यहीं मिल जाएगा।

KNN एल्गोरिद्म को दर्शाने के लिए, यह ट्यूटोरियल class पैकेज के साथ काम करता है:

library(.....)

यदि आपके पास यह पैकेज अभी नहीं है, तो आप निम्न पंक्ति टाइप करके इसे जल्दी और आसानी से कर सकते हैं:

install.packages("<package name>")संचालित द्वारा

याद रखें नर्ड टिप: यदि आप पक्का नहीं हैं कि यह पैकेज है या नहीं, तो पता लगाने के लिए आप निम्न कमांड चला सकते हैं!

any(grepl("<name of your package>", installed.packages()))संचालित द्वारा

चरण पाँच. अपना डेटा तैयार करें

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

सामान्यीकरण (Normalization)

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

• उदाहरण सामान्यीकरण में हर उदाहरण को अलग-अलग समायोजित किया जाता है, जबकि
• फीचर सामान्यीकरण का मतलब है कि आप सभी उदाहरणों में हर फीचर को एक ही तरीके से समायोजित करते हैं।

तो आपको अपना डेटा सेट कब सामान्यीकृत करना चाहिए?

संक्षेप में: जब आपको संदेह हो कि डेटा सुसंगत नहीं है।

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

उदाहरण के लिए, यदि आपके डेटा सेट में केवल दो एट्रिब्यूट X और Y हैं, और X के मान 1 से 1000 तक हैं, जबकि Y के मान केवल 1 से 100 तक हैं, तो दूरी फ़ंक्शन पर Y का प्रभाव आमतौर पर X के प्रभाव से दब जाएगा।

जब आप सामान्यीकृत करते हैं, तो आप वास्तव में सभी फीचर्स की रेंज समायोजित करते हैं, ताकि अधिक रेंज वाले वेरिएबल्स के बीच की दूरी को ज़रूरत से ज़्यादा महत्व न मिल जाए।

टिप: summary(iris) के परिणाम पर वापस जाएँ और यह समझने की कोशिश करें कि सामान्यीकरण आवश्यक है या नहीं।

Iris डेटा सेट को सामान्यीकृत करने की ज़रूरत नहीं है: Sepal.Length के मान 4.3 से 7.9 तक हैं और Sepal.Width में 2 से 4.4 तक, जबकि Petal.Length के मान 1 से 6.9 तक और Petal.Width 0.1 से 2.5 तक हैं। सभी एट्रिब्यूट्स के सभी मान 0.1 और 7.9 की रेंज में आते हैं, जिसे आप स्वीकार्य मान सकते हैं।

फिर भी, सामान्यीकरण और उसके प्रभाव का अध्ययन करना अच्छा विचार है, खासकर यदि आप मशीन लर्निंग में नए हैं। आप उदाहरण के लिए, पहले अपना normalize() फ़ंक्शन बनाकर फीचर सामान्यीकरण कर सकते हैं।

इसके बाद आप इस आर्ग्युमेंट को एक अन्य कमांड में उपयोग कर सकते हैं, जहाँ lapply() फ़ंक्शन आपके दिए गए डेटा सेट की ही लंबाई की एक सूची लौटाने के बाद, आप as.data.frame() के माध्यम से सामान्यीकरण के परिणामों को एक डेटा फ़्रेम में रखते हैं। उस सूची का प्रत्येक तत्व इनपुट डेटा सेट पर normalize आर्ग्युमेंट के अनुप्रयोग का परिणाम होता है:

YourNormalizedDataSet <- as.data.frame(lapply(YourDataSet, normalize))संचालित द्वारा

इसे नीचे दिए गए DataCamp Light खंड में आज़माएँ!

# Build your own `normalize()` function
normalize <- function(x) {
num <- x - min(x)
denom <- max(x) - min(x)
return (num/denom)
}

# Normalize the `iris` data
iris_norm <- .............(......(iris[1:4], normalize))

# Summarize `iris_norm`
summary(.........)

Iris डेटा सेट के लिए, आपने normalize आर्ग्युमेंट को Iris डेटा सेट के चार संख्यात्मक एट्रिब्यूट्स (Sepal.Length, Sepal.Width, Petal.Length, Petal.Width) पर लागू किया होगा और परिणामों को एक डेटा फ़्रेम में रखा होगा।

टिप: डेटा सेट पर सामान्यीकरण के प्रभाव को और गहराई से दिखाने के लिए, निम्न परिणाम की तुलना चरण दो में दिए गए Iris डेटा सेट के सारांश से करें।

प्रशिक्षण और परीक्षण सेट

बाद में अपने मॉडल के प्रदर्शन का आकलन करने के लिए, आपको डेटा सेट को दो भागों में बाँटना होगा: प्रशिक्षण सेट और परीक्षण सेट।

पहला सिस्टम को प्रशिक्षित करने के लिए इस्तेमाल होता है, जबकि दूसरा सीखे या प्रशिक्षित सिस्टम का मूल्यांकन करने के लिए। व्यवहार में, आपके डेटा सेट का परीक्षण और प्रशिक्षण सेट में विभाजन असंपर्क (disjoint) होता है: सबसे आम विभाजन यह है कि आप अपने मूल डेटा सेट के 2/3 हिस्से को प्रशिक्षण सेट के रूप में लें, जबकि शेष 1/3 परीक्षण सेट बने।

डेटा सेट पर एक आखिरी नज़र यह सिखाती है कि यदि आपने जैसा-का-तैसा विभाजन किया, तो आपको एक प्रशिक्षण वर्ग मिलेगा जिसमें “Setosa” और “Versicolor” की सभी प्रजातियाँ होंगी, पर “Virginica” नहीं। इसलिए मॉडल सभी अज्ञात इंस्टेंस को या तो “Setosa” या “Versicolor” के रूप में वर्गीकृत करेगा, क्योंकि उसे डेटा में फूलों की तीसरी प्रजाति की उपस्थिति का पता ही नहीं होगा।

संक्षेप में, आपको परीक्षण सेट के लिए गलत भविष्यवाणियाँ मिलेंगी।

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

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

set.seed(1234)संचालित द्वारा

फिर, आप सुनिश्चित करना चाहते हैं कि आपका Iris डेटा सेट शफल हो और आपके प्रशिक्षण व परीक्षण सेटों में प्रत्येक प्रजाति की बराबर मात्रा हो।

आप sample() फ़ंक्शन का उपयोग करके एक सैंपल लेते हैं जिसका आकार Iris डेटा सेट की पंक्तियों की संख्या, यानी 150, के बराबर है। आप रिप्लेसमेंट के साथ सैंपल लेते हैं: आप 2 तत्वों के एक वेक्टर से चुनते हैं और Iris डेटा सेट की 150 पंक्तियों को या तो 1 या 2 असाइन करते हैं। तत्वों के असाइनमेंट पर 0.67 और 0.33 की प्रायिकता वेट लागू होते हैं।

ind <- sample(2, nrow(iris), replace=TRUE, prob=c(0.67, 0.33))संचालित द्वारा

ध्यान दें कि replace आर्ग्युमेंट TRUE पर सेट है: इसका मतलब है कि आप किसी पंक्ति को 1 या 2 असाइन करते हैं और फिर 2 के वेक्टर को उसकी मूल स्थिति में रीसेट कर देते हैं। इसका अर्थ यह है कि आपके डेटा सेट की अगली पंक्तियों के लिए आप हर बार फिर से 1 या 2 असाइन कर सकते हैं। 1 या 2 चुनने की प्रायिकता शेष आइटमों के बीच के वेट के अनुपात में नहीं होनी चाहिए, इसलिए आप प्रायिकता वेट निर्दिष्ट करते हैं। यह भी ध्यान दें कि, भले ही आपको DataCamp Light खंड में यह न दिखे, seed अभी भी 1234 पर सेट है।

याद रखें कि आप अपने प्रशिक्षण सेट को मूल डेटा सेट का 2/3 रखना चाहते हैं: इसलिए आप 150 सैंपल पंक्तियों को 0.67 की प्रायिकता से “1” और 0.33 की प्रायिकता से “2” असाइन करते हैं।

फिर आप ind चर में संग्रहित सैंपल का उपयोग करके अपने प्रशिक्षण और परीक्षण सेट परिभाषित कर सकते हैं:

# Compose training set
iris.training <- ....[ind==1, 1:4]

# Inspect training set
head(................)

# Compose test set
iris.test <- ....[ind==2, 1:4]

# Inspect test set
head(...........)

ध्यान दें कि ऊपर निर्दिष्ट 2/3 और 1/3 अनुपात के अलावा, आप प्रशिक्षण और परीक्षण सेट बनाने के लिए सभी एट्रिब्यूट्स को ध्यान में नहीं लेते। खास तौर पर, आप केवल Sepal.Length, Sepal.Width, Petal.Length और Petal.Width लेते हैं। इसका कारण यह है कि आप वास्तव में पाँचवें एट्रिब्यूट Species की भविष्यवाणी करना चाहते हैं: यह आपका लक्ष्य वेरिएबल है। हालांकि, आप इसे KNN एल्गोरिद्म में शामिल करना चाहते हैं, नहीं तो इसकी कभी कोई भविष्यवाणी ही नहीं होगी।

इसलिए आपको क्लास लेबल्स को फैक्टर वेक्टर में संग्रहित करना होगा और उन्हें प्रशिक्षण और परीक्षण सेटों में बाँटना होगा:

# Compose `iris` training labels
iris.trainLabels <- iris[ind==1,5]

# Inspect result
print(iris.trainLabels)

# Compose `iris` test labels
iris.testLabels <- iris[ind==2, 5]

# Inspect result
print(iris.testLabels)

चरण छह. वास्तविक KNN मॉडल

अपना क्लासिफायर बनाना

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

इन दो चरणों को पूरा करने का एक आसान तरीका knn() फ़ंक्शन का उपयोग करना है, जो यूक्लिडियन दूरी माप का उपयोग करता है ताकि आपकी नई, अज्ञात इंस्टैंस के k निकटतम पड़ोसी ढूंढे जा सकें। यहाँ, k पैरामीटर वह है जिसे आप स्वयं निर्धारित करते हैं।

जैसा कि पहले उल्लेख किया गया है, नई इंस्टैंसेज़ को बहुमत मत या वेटेड मत देखकर वर्गीकृत किया जाता है। वर्गीकरण के मामले में, सबसे अधिक स्कोर वाला डेटा पॉइंट जीतता है और अज्ञात इंस्टैंस को उसी विजेता डेटा पॉइंट का लेबल मिलता है। यदि बराबरी हो जाती है, तो वर्गीकरण यादृच्छिक रूप से होता है।

ध्यान दें: k पैरामीटर अक्सर विषम संख्या होता है ताकि वोटिंग स्कोर में टाई से बचा जा सके।

अपना क्लासिफायर बनाने के लिए, आपको knn() फ़ंक्शन लेना है और इसमें कुछ आर्ग्युमेंट्स जोड़ने हैं, जैसे इस उदाहरण में:

# Build the model
iris_pred <- ...(train = iris.training, test = iris.test, cl = iris.trainLabels, k=3)

# Inspect `iris_pred`
.........

आप iris_pred में उस knn() फ़ंक्शन का परिणाम स्टोर करते हैं जो आर्ग्युमेंट्स के रूप में ट्रेनिंग सेट, टेस्ट सेट, ट्रेन लेबल्स और इस एल्गोरिद्म से ढूंढे जाने वाले पड़ोसियों की संख्या लेता है। इस फ़ंक्शन का परिणाम एक फ़ैक्टर वेक्टर होता है, जिसमें टेस्ट डेटा की प्रत्येक पंक्ति के लिए अनुमानित क्लास होती है।

ध्यान दें कि आप टेस्ट लेबल्स नहीं डालना चाहते: इन्हें यह जाँचने के लिए उपयोग किया जाएगा कि आपका मॉडल आपकी इंस्टैंसेज़ की वास्तविक क्लास का कितना सही अनुमान लगाता है!

आप देखते हैं कि जब आप परिणाम, iris_pred, को देखते हैं, तो आपको टेस्ट डेटा की प्रत्येक पंक्ति के लिए अनुमानित क्लास वाला फ़ैक्टर वेक्टर मिलता है।

चरण सात. अपने मॉडल का मूल्यांकन

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

एक अधिक अमूर्त दृष्टिकोण के लिए, आप बस iris_pred के परिणामों की तुलना पहले से परिभाषित किए गए टेस्ट लेबल्स से कर सकते हैं:

# Put `iris.testLabels` in a data frame
irisTestLabels <- data.frame(................)

# Merge `iris_pred` and `iris.testLabels` 
merge <- data.frame(........., ...............)

# Specify column names for `merge`
names(.....) <- c("Predicted Species", "Observed Species")

# Inspect `merge` 
merge

आप देखते हैं कि मॉडल पर्याप्त रूप से सटीक भविष्यवाणियाँ करता है, सिवाय पंक्ति 29 में एक गलत वर्गीकरण के, जहाँ “Versicolor” भविष्यवाणी की गई थी जबकि टेस्ट लेबल “Virginica” है।

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

install.packages("package name")संचालित द्वारा

हालाँकि, यदि आपने यह पैकेज पहले से इंस्टॉल किया है, तो आप बस यह दर्ज कर सकते हैं

library(gmodels)संचालित द्वारा

इसके बाद आप एक क्रॉस-टैबुलेशन या कॉन्टिन्जेंसी टेबल बना सकते हैं। इस प्रकार की तालिका अक्सर दो चर के बीच संबंध समझने के लिए उपयोग की जाती है। इस मामले में, आप समझना चाहते हैं कि आपके टेस्ट डेटा की क्लासेस, जो iris.testLabels में संग्रहीत हैं, आपके मॉडल से, जो iris_pred में संग्रहीत है, कैसे संबंधित हैं:

CrossTable(x = iris.testLabels, y = iris_pred, prop.chisq=FALSE)संचालित द्वारा

ध्यान दें कि अंतिम आर्ग्युमेंट prop.chisq यह दर्शाता है कि प्रत्येक सेल के chi-square योगदान को शामिल किया जाए या नहीं। chi-square सांख्यिकीय मान व्यक्तिगत कोशिकाओं के योगदानों का योग होता है और यह तय करने के लिए उपयोग होता है कि प्रेक्षित और अपेक्षित मानों के बीच का अंतर महत्वपूर्ण है या नहीं।

इस तालिका से, आप सही और गलत भविष्यवाणियों की संख्या निकाल सकते हैं: टेस्टिंग सेट की एक इंस्टैंस को मॉडल ने Versicolor के रूप में लेबल किया, जबकि वह वास्तव में Virginica प्रजाति का फूल था। आप इसे iris.testLabels कॉलम में “Virginica” प्रजाति की पहली पंक्ति में देख सकते हैं। अन्य सभी मामलों में, सही भविष्यवाणियाँ की गईं। आप निष्कर्ष निकाल सकते हैं कि मॉडल का प्रदर्शन पर्याप्त रूप से अच्छा है और आपको मॉडल में सुधार करने की आवश्यकता नहीं है!

R में मशीन लर्निंग caret के साथ

पिछले अनुभागों में, आपने R में KNN एल्गोरिद्म के माध्यम से सुपरवाइज़्ड लर्निंग शुरू की। जैसा कि आप ऊपर देख चुके हैं, R में मशीन लर्निंग वास्तव में जटिल हो सकती है, क्योंकि अलग-अलग एल्गोरिद्म हैं, अलग-अलग सिंटैक्स, भिन्न पैरामीटर्स, आदि। शायद आप मुझसे सहमत होंगे कि हर एल्गोरिद्म के लिए अलग-अलग पैकेज नाम याद रखना काफ़ी कठिन हो सकता है या हर विशिष्ट एल्गोरिद्म की सिंटैक्स लागू करना बहुत अधिक हो जाता है।

यहीं पर caret पैकेज काम आता है: यह “Classification and Regression Training” का संक्षिप्त रूप है और सुपरवाइज़्ड मशीन लर्निंग समस्याओं को सुलझाने के लिए ज़रूरी सब कुछ प्रदान करता है: यह ढेर सारे मशीन लर्निंग एल्गोरिद्म के लिए एक समान इंटरफ़ेस उपलब्ध कराता है। यदि आप Python मशीन लर्निंग से थोड़ा परिचित हैं, तो आपको scikit-learn से समानताएँ दिख सकती हैं!

आगे, आप उन चरणों से गुजरेंगे जिन्हें ऊपर रेखांकित किया गया है, पर इस बार आप अपने डेटा को वर्गीकृत करने के लिए caret का उपयोग करेंगे। ध्यान दें कि यदि आपने ऊपर बताए गए चरणों का पालन किया है तो आपने पहले ही काफी काम कर लिया है: आपके पास अपने डेटा पर पकड़ है, आपने उसे खोजा है, अपना वर्कस्पेस तैयार किया है, आदि। अब समय है कि आप caret के साथ अपने डेटा का प्रीप्रोसेसिंग करें!

जैसा कि आपने पहले किया था, आप नॉर्मलाइज़ेशन के प्रभाव का अध्ययन कर सकते हैं, लेकिन आप इसे ट्यूटोरियल में आगे देखेंगे।

आप पहले से जानते हैं कि आगे क्या है! आइए डेटा को ट्रेनिंग और टेस्ट सेट में बाँटते हैं। हालाँकि, इस मामले में, आप चीज़ों को थोड़ा अलग तरीके से संभालते हैं: आप iris$Species में पाए जाने वाले लेबल्स के आधार पर डेटा को विभाजित करते हैं। साथ ही, इस मामले में ट्रेनिंग और टेस्ट सेट के लिए अनुपात 75-25 रखा गया है।

# Create index to split based on labels  
index <- createDataPartition(iris$Species, p=0.75, list=FALSE)

# Subset training set with index
iris.training <- iris[.......,]

# Subset test set with index
iris.test <- iris[-.........,]

अब आप मॉडल्स ट्रेन करने के लिए पूरी तरह तैयार हैं! लेकिन, जैसा कि आपको याद होगा, caret एक अत्यंत बड़ा प्रोजेक्ट है जिसमें बहुत सारे एल्गोरिद्म शामिल हैं। यदि आपको संदेह है कि प्रोजेक्ट में कौन-कौन से एल्गोरिद्म शामिल हैं, तो आप उन सभी की सूची प्राप्त कर सकते हैं। names(getModelInfo()) चलाकर सूची देखें, जैसा कि नीचे दिया गया कोड खंड दिखाता है। इसके बाद, कोई एल्गोरिद्म चुनें और train() फ़ंक्शन से मॉडल ट्रेन करें:

# Overview of algos supported by caret
names(getModelInfo())

# Train a model
model_knn <- train(iris.training[, 1:4], iris.training[, 5], method='knn')

ध्यान दें कि जब आप यहाँ तक पहुँच जाते हैं तो अन्य मॉडल बनाना अत्यंत सरल हो जाता है; आपको बस method आर्ग्युमेंट बदलना होता है, जैसे इस उदाहरण में:

model_cart <- train(iris.training[, 1:4], iris.training[, 5], method='rpart2')संचालित द्वारा

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

# Predict the labels of the test set
predictions<-predict(object=model_knn,iris.test[,1:4])

# Evaluate the predictions
table(predictions)

# Confusion matrix 
confusionMatrix(predictions,iris.test[,5])

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

# Train the model with preprocessing
model_knn <- train(iris.training[, 1:4], iris.training[, 5], method='knn', preProcess=c("center", "scale"))

# Predict values
predictions<-predict.train(object=model_knn,iris.test[,1:4], type="raw")

# Confusion matrix
confusionMatrix(predictions,iris.test[,5])

बिग डेटा की ओर बढ़ें

बधाई हो! आप इस ट्यूटोरियल को पूरा कर चुके हैं!

यह ट्यूटोरियल मुख्य रूप से R की मदद से बुनियादी मशीन लर्निंग एल्गोरिद्म KNN को करने पर केंद्रित था। इस्तेमाल किया गया Iris डेटा सेट छोटा और सुगम था; न केवल आपने देखा कि आप ये सभी चरण स्वयं कैसे कर सकते हैं, बल्कि आपने यह भी देखा कि आप caret जैसे एक समान इंटरफ़ेस का आसानी से उपयोग कैसे कर सकते हैं, ताकि आपकी मशीन लर्निंग तेज़ी से आगे बढ़ सके।

पर आप इससे कहीं अधिक कर सकते हैं!

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