उदाहरण के साथ आर प्रोग्रामिंग में फ़ंक्शन
एवलिन क्लार्क
⚡ स्मार्ट सारांश
R में फ़ंक्शन निर्देशों के एक समूह को एक ही नाम के अंतर्गत रखते हैं, इसलिए एक ही कॉल से दोहराया जाने वाला कार्य चलता है। इसमें अंतर्निहित गणित और सांख्यिकी सहायक, उपयोगकर्ता-परिभाषित फ़ंक्शन, पर्यावरण स्कोरिंग आदि शामिल हैं।pingयहां सशर्त तर्कों को उदाहरणों सहित समझाया गया है।
आर में फ़ंक्शन क्या है?
A समारोहप्रोग्रामिंग वातावरण में, निर्देशों का एक सेट है। एक प्रोग्रामर किसी फ़ंक्शन का निर्माण करता है ताकि वह किसी भी तरह की परेशानी से बच सके। एक ही कार्य को दोहराना, या कम करें जटिलता.
एक समारोह होना चाहिए
- किसी विशिष्ट कार्य को पूरा करने के लिए लिखा गया
- इसमें तर्क शामिल हो भी सकते हैं और नहीं भी
- एक शरीर शामिल
- यह एक या अधिक मान लौटा सकता है या नहीं भी लौटा सकता है।
किसी फ़ंक्शन के लिए एक सामान्य दृष्टिकोण तर्क भाग का उपयोग करना है निविष्टियां, खिलाओ परिवर्तन भाग और अंत में वापसी उत्पादनफ़ंक्शन का सिंटैक्स निम्नलिखित है:
function (arglist) { #Function body }
आर महत्वपूर्ण अंतर्निहित कार्य
R में बहुत सारे बिल्ट-इन फ़ंक्शन हैं। R आपके इनपुट पैरामीटर को अपने फ़ंक्शन तर्कों से, या तो मान या स्थिति के आधार पर, मैच करता है, फिर फ़ंक्शन बॉडी को निष्पादित करता है। फ़ंक्शन तर्कों में डिफ़ॉल्ट मान हो सकते हैं: यदि आप इन तर्कों को निर्दिष्ट नहीं करते हैं, तो R डिफ़ॉल्ट मान लेगा।
नोट:
कंसोल में फ़ंक्शन का नाम चलाकर फ़ंक्शन का स्रोत कोड देखना संभव है।
Typing कोष्ठक के बिना फ़ंक्शन का नाम लिखने पर उसका स्रोत कोड प्रिंट होता है, जैसा कि नीचे दिए गए कंसोल में दिखाया गया है।
हम कार्य के तीन समूहों को क्रियाशील देखेंगे
- सामान्य कार्य
- गणित फ़ंक्शन
- सांख्यिकीय कार्य
सामान्य कार्य
हम पहले से ही cbind(), rbind(), range() जैसे सामान्य कार्यों से परिचित हैं। क्रमबद्ध करें ()और order() फ़ंक्शन। इनमें से प्रत्येक फ़ंक्शन का एक विशिष्ट कार्य होता है, और ये आउटपुट देने के लिए आर्गुमेंट्स लेते हैं। निम्नलिखित कुछ महत्वपूर्ण फ़ंक्शन हैं जिन्हें जानना आवश्यक है-
diff() फ़ंक्शन
यदि आप काम करते हैं समय श्रृंखला, आपको उनकी श्रृंखला को स्थिर करने की आवश्यकता है विलम्ब मान. एक स्थिर प्रक्रिया यह फ़ंक्शन समय के साथ स्थिर माध्य, प्रसरण और स्वसहसंबंध की अनुमति देता है। इससे मुख्य रूप से समय श्रृंखला के पूर्वानुमान में सुधार होता है। यह diff() फ़ंक्शन की सहायता से किया जा सकता है। हम एक प्रवृत्ति के साथ यादृच्छिक समय-श्रृंखला डेटा बना सकते हैं और फिर श्रृंखला को स्थिर करने के लिए diff() फ़ंक्शन का उपयोग कर सकते हैं। diff() फ़ंक्शन एक तर्क, एक सदिश, स्वीकार करता है और उपयुक्त अंतराल और पुनरावृत्त अंतर लौटाता है।
नोटहमें अक्सर यादृच्छिक डेटा बनाने की आवश्यकता होती है, लेकिन सीखने और तुलना के लिए हम चाहते हैं कि सभी मशीनों पर संख्याएँ समान हों। यह सुनिश्चित करने के लिए कि हम सभी एक ही डेटा उत्पन्न करें, हम set.seed() फ़ंक्शन का उपयोग 123 के मनमाने मानों के साथ करते हैं। set.seed() छद्म-यादृच्छिक संख्या जनरेटर के प्रारंभिक बिंदु को निर्धारित करता है, जिससे प्रत्येक मशीन एक ही अनुक्रम उत्पन्न करती है। set.seed() के बिना, प्रत्येक रन एक अलग अनुक्रम लौटाता है।
set.seed(123) ## Create the data x = rnorm(1000) ts <- cumsum(x) ## Stationary the serie diff_ts <- diff(ts) par(mfrow=c(1,2)) ## Plot the series plot(ts, type='l') plot(diff(ts), type='l')
नीचे दिए गए दो पैनल मूल संचयी श्रृंखला को अंतरित श्रृंखला के बगल में रखते हैं, जो अब एक स्थिर माध्य के आसपास उतार-चढ़ाव करती है।
लंबाई() फ़ंक्शन
कई मामलों में, हमें गणना के लिए या फॉर लूप में उपयोग करने के लिए वेक्टर की लंबाई जानने की आवश्यकता होती है। length() फ़ंक्शन वेक्टर x में पंक्तियों की संख्या गिनता है। निम्नलिखित कोड cars डेटासेट को आयात करता है और पंक्तियों की संख्या लौटाता है।
नोटlength() फ़ंक्शन एक वेक्टर में तत्वों की संख्या लौटाता है। यदि फ़ंक्शन को किसी अन्य फ़ंक्शन में पास किया जाता है, तो यह मान अलग हो जाता है। मैट्रिक्स या फिर डेटा फ्रेम के लिए, कॉलम की संख्या लौटाई जाती है।
dt <- cars
## number columns
length(dt)
आउटपुट:
## [1] 1
## number rows
length(dt[,1])
आउटपुट:
## [1] 50
गणित के कार्य
सामान्य सहायक फ़ंक्शनों के अलावा, R में गणितीय फ़ंक्शनों की एक श्रृंखला है जो एक वेक्टर पर तत्व दर तत्व कार्य करती है।
| Operaटो | विवरण |
|---|---|
| एब्स (x) | x का निरपेक्ष मान लेता है |
| लॉग(x, आधार=y) | आधार y के साथ x का लघुगणक लेता है; यदि आधार निर्दिष्ट नहीं है, तो प्राकृतिक लघुगणक लौटाता है |
| क्स्प (एक्स) | x का घातांक लौटाता है |
| sqrt (x) | x का वर्गमूल लौटाता है |
| फैक्टोरियल(x) | x (x!) का फैक्टोरियल लौटाता है |
# sequence of number from 44 to 55 both including incremented by 1 x_vector <- seq(45,55, by = 1) #logarithm log(x_vector)
आउटपुट:
## [1] 3.806662 3.828641 3.850148 3.871201 3.891820 3.912023 3.931826 ## [8] 3.951244 3.970292 3.988984 4.007333
#exponential
exp(x_vector)
#squared root
sqrt(x_vector)
आउटपुट:
## [1] 6.708204 6.782330 6.855655 6.928203 7.000000 7.071068 7.141428 ## [8] 7.211103 7.280110 7.348469 7.416198
#factorial
factorial(x_vector)
आउटपुट:
## [1] 1.196222e+56 5.502622e+57 2.586232e+59 1.241392e+61 6.082819e+62 ## [6] 3.041409e+64 1.551119e+66 8.065818e+67 4.274883e+69 2.308437e+71 ## [11] 1.269640e+73
सांख्यिकीय कार्य
जहां गणितीय फ़ंक्शन मानों को रूपांतरित करते हैं, वहीं सांख्यिकीय फ़ंक्शन उन्हें सारांशित करते हैं। R के मानक इंस्टॉलेशन में सांख्यिकीय फ़ंक्शनों की एक विस्तृत श्रृंखला शामिल है। इस ट्यूटोरियल में, हम संक्षेप में सबसे महत्वपूर्ण फ़ंक्शनों पर नज़र डालेंगे।
बुनियादी सांख्यिकी कार्य
| Operaटो | विवरण |
|---|---|
| माध्य(x) | x का माध्य |
| माध्यिका(x) | x का माध्यिका |
| var(x) | x का विचरण |
| एसडी(x) | x का मानक विचलन |
| स्केल(x) | मानक स्कोर (z-स्कोर) x |
| क्वांटाइल(x) | x के चतुर्थक |
| सारांश(x) | x का सारांश: माध्य, न्यूनतम, अधिकतम आदि.. |
speed <- dt$speed
speed
# Mean speed of cars dataset
mean(speed)
आउटपुट:
## [1] 15.4
# Median speed of cars dataset
median(speed)
आउटपुट:
## [1] 15
# Variance speed of cars dataset
var(speed)
आउटपुट:
## [1] 27.95918
# Standard deviation speed of cars dataset
sd(speed)
आउटपुट:
## [1] 5.287644
# Standardize vector speed of cars dataset
head(scale(speed), 5)
आउटपुट:
## [,1] ## [1,] -2.155969 ## [2,] -2.155969 ## [3,] -1.588609 ## [4,] -1.588609 ## [5,] -1.399489
# Quantile speed of cars dataset
quantile(speed)
आउटपुट:
## 0% 25% 50% 75% 100% ## 4 12 15 19 25
# Summary speed of cars dataset
summary(speed)
आउटपुट:
## Min. 1st Qu. Median Mean 3rd Qu. Max. ## 4.0 12.0 15.0 15.4 19.0 25.0
अब तक हमने R के बहुत से अंतर्निहित कार्यों के बारे में सीख लिया है।
नोटसावधान रहें तर्क का वर्गयानी, संख्यात्मक, बूलियन या स्ट्रिंग। उदाहरण के लिए, यदि हमें एक स्ट्रिंग मान पास करना है, तो हमें स्ट्रिंग को उद्धरण चिह्न में बंद करना होगा: “ABC”।
R में फ़ंक्शन लिखें
कुछ अवसरों पर, हमें अपना स्वयं का फ़ंक्शन लिखने की आवश्यकता होती है क्योंकि हमें एक विशेष कार्य पूरा करना होता है और कोई तैयार फ़ंक्शन मौजूद नहीं होता है। एक उपयोगकर्ता-परिभाषित फ़ंक्शन में शामिल होता है... नाम, तर्क और एक परिवर्तन.
function.name <- function(arguments) { computations on the arguments some other code }
नोट: एक अच्छा अभ्यास यह है कि उपयोगकर्ता-परिभाषित फ़ंक्शन को बिल्ट-इन फ़ंक्शन से अलग नाम दिया जाए। इससे भ्रम की स्थिति से बचा जा सकता है।
एक तर्क फ़ंक्शन
अगले स्निपेट में, हम एक सरल वर्ग फ़ंक्शन परिभाषित करते हैं। फ़ंक्शन एक मान स्वीकार करता है और मान का वर्ग लौटाता है।
square_function<- function(n) { # compute the square of integer `n` n^2 } # calling the function and passing value 4 square_function(4)
Code व्याख्या
- इस फ़ंक्शन का नाम square_function है; इसे हम जो चाहें कह सकते हैं।
- इसे एक तर्क “n” प्राप्त होता है। हम चर का प्रकार निर्दिष्ट नहीं किया गया ताकि उपयोगकर्ता पूर्णांक, सदिश या मैट्रिक्स पास कर सके
- फ़ंक्शन इनपुट “n” लेता है और इनपुट का वर्ग लौटाता है। जब आप फ़ंक्शन का उपयोग कर लेते हैं, तो हम इसे rm() फ़ंक्शन से हटा सकते हैं।
# फ़ंक्शन बनाने के बाद
rm(square_function) square_function
कंसोल पर, हम एक त्रुटि संदेश देख सकते हैं: त्रुटि: ऑब्जेक्ट 'square_function' नहीं मिला, जो बताता है कि फ़ंक्शन मौजूद नहीं है।
पर्यावरण स्कोping
आर में, वातावरण यह फंक्शन, वेरिएबल, डेटा फ्रेम आदि जैसी वस्तुओं का एक संग्रह है।
RStudio के हर बार शुरू होने पर R एक नया वातावरण खोलता है।
उपलब्ध शीर्ष-स्तरीय वातावरण है वैश्विक पर्यावरणजिसे R_GlobalEnv कहा जाता है। और हमारे पास है स्थानीय पर्यावरण.
हम वर्तमान परिवेश की सामग्री को सूचीबद्ध कर सकते हैं।
ls(environment())
उत्पादन
## [1] "diff_ts" "dt" "speed" "square_function" ## [5] "ts" "x" "x_vector"
आप R_GlobalEnv में बनाए गए सभी वेरिएबल्स और फ़ंक्शन देख सकते हैं।
ऊपर दी गई सूची आपके लिए RStudio में आपके द्वारा निष्पादित किए गए ऐतिहासिक कोड के आधार पर भिन्न हो सकती है।
ध्यान दें कि nsquare_function फ़ंक्शन का तर्क इस वैश्विक वातावरण में नहीं है।
प्रत्येक फ़ंक्शन के लिए एक नया वातावरण बनाया जाता है। ऊपर दिए गए उदाहरण में, square_function() फ़ंक्शन के अंदर एक नया वातावरण बनाता है। वैश्विक पर्यावरण.
के बीच अंतर को स्पष्ट करने के लिए वैश्विक और स्थानीय पर्यावरण, आइए निम्नलिखित उदाहरण का अध्ययन करें
ये फ़ंक्शन एक मान x को एक तर्क के रूप में लेता है और इसे फ़ंक्शन के बाहर और अंदर परिभाषित y में जोड़ता है
फ़ंक्शन f आउटपुट 15 लौटाता है। ऐसा इसलिए है क्योंकि y को वैश्विक वातावरण में परिभाषित किया गया है। वैश्विक वातावरण में परिभाषित किसी भी चर का स्थानीय रूप से उपयोग किया जा सकता है। सभी फ़ंक्शन कॉल के दौरान चर y का मान 10 होता है और इसे किसी भी समय एक्सेस किया जा सकता है।
आइए देखें कि यदि चर y को फ़ंक्शन के अंदर परिभाषित किया जाए तो क्या होता है।
rm r का उपयोग करके इस कोड को चलाने से पहले हमें `y` को हटाना होगा
जब हम f(15) को कॉल करते हैं तो आउटपुट भी 5 होता है, लेकिन जब हम y का मान प्रिंट करने की कोशिश करते हैं तो एक त्रुटि रिटर्न होती है। चर y वैश्विक वातावरण में नहीं है।
अंत में, R फ़ंक्शन के मुख्य भाग के अंदर पास करने के लिए सबसे हाल ही में प्राप्त वैरिएबल परिभाषा का उपयोग करता है। आइए निम्न उदाहरण पर विचार करें:
R फ़ंक्शन के बाहर परिभाषित y मानों को अनदेखा करता है क्योंकि हमने फ़ंक्शन के मुख्य भाग के अंदर स्पष्ट रूप से एक चर बनाया है।
बहु तर्क फ़ंक्शन
हम एक से ज़्यादा तर्कों वाला फ़ंक्शन लिख सकते हैं। “times” नामक फ़ंक्शन पर विचार करें। यह दो चरों को गुणा करने वाला एक सीधा फ़ंक्शन है।
times <- function(x,y) {
x*y
}
times(2,4)
आउटपुट:
## [1] 8
हमें फ़ंक्शन कब लिखना चाहिए?
डेटा वैज्ञानिकों को कई दोहराव वाले कार्य करने पड़ते हैं। अधिकांश समय, हम कोड के हिस्सों को बार-बार कॉपी और पेस्ट करते हैं। उदाहरण के लिए, किसी भी प्रक्रिया को चलाने से पहले वेरिएबल का नॉर्मलाइज़ेशन करना अत्यंत आवश्यक है। यंत्र अधिगम एल्गोरिथ्म। किसी चर को सामान्य करने का सूत्र है:
हम पहले से ही जानते हैं कि R में min() और max() फ़ंक्शन का उपयोग कैसे किया जाता है। डेटा फ़्रेम बनाने के लिए हम tibble लाइब्रेरी का उपयोग करते हैं। स्क्रैच से डेटा सेट बनाने के लिए Tibble अब तक का सबसे सुविधाजनक फ़ंक्शन है।
library(tibble) # Create a data frame data_frame <- tibble( c1 = rnorm(50, 5, 1.5), c2 = rnorm(50, 5, 1.5), c3 = rnorm(50, 5, 1.5), )
ऊपर वर्णित फ़ंक्शन की गणना करने के लिए हम दो चरणों का पालन करेंगे। पहले चरण में, हम c1_norm नामक एक चर बनाएंगे, जो c1 का पुनर्वर्गीकरण है। दूसरे चरण में, हम c1_norm के कोड को कॉपी-पेस्ट करेंगे और उसमें c2 और c3 के मान जोड़ेंगे।
स्तंभ c1 वाले फ़ंक्शन का विवरण:
नामांकितकर्ता: : data_frame$c1 -min(data_frame$c1))
हर: अधिकतम(data_frame$c1)-न्यूनतम(data_frame$c1))
इसलिए, हम स्तंभ c1 का सामान्यीकृत मान प्राप्त करने के लिए उन्हें विभाजित कर सकते हैं:
(data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1))
हम c1_norm, c2_norm और c3_norm बना सकते हैं:
Create c1_norm: rescaling of c1
data_frame$c1_norm <- (data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1))
# show the first five values
head(data_frame$c1_norm, 5)
आउटपुट:
## [1] 0.3400113 0.4198788 0.8524394 0.4925860 0.5067991
यह काम करता है। हम कॉपी और पेस्ट कर सकते हैं
data_frame$c1_norm <- (data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1))
फिर c1_norm को c2_norm में बदलें और c1 को c2 में बदलें। हम c3_norm बनाने के लिए भी यही करते हैं
data_frame$c2_norm <- (data_frame$c2 - min(data_frame$c2))/(max(data_frame$c2)-min(data_frame$c2)) data_frame$c3_norm <- (data_frame$c3 - min(data_frame$c3))/(max(data_frame$c3)-min(data_frame$c3))
हमने चर c1, c2 और c3 को पूरी तरह से पुनः मापित किया।
हालांकि, इस विधि में गलतियाँ होने की संभावना रहती है। हम कोड कॉपी कर सकते हैं और पेस्ट करने के बाद कॉलम का नाम बदलना भूल सकते हैं। इसलिए, बेहतर यही होगा कि जब भी आपको एक ही कोड को दो से अधिक बार पेस्ट करना हो, तो एक फ़ंक्शन लिखें। हम कोड को एक फ़ॉर्मूला में व्यवस्थित कर सकते हैं और ज़रूरत पड़ने पर उसे कॉल कर सकते हैं। अपना फ़ंक्शन लिखने के लिए, हमें निम्नलिखित जानकारी देनी होगी:
- नाम: सामान्य करें।
- तर्कों की संख्या: हमें केवल एक तर्क की आवश्यकता है, जो कि वह कॉलम है जिसका उपयोग हम अपनी गणना में करते हैं।
- शरीर: यह बस वह सूत्र है जिसे हम वापस करना चाहते हैं।
हम फंक्शन नॉर्मलाइज़ बनाने के लिए चरण दर चरण आगे बढ़ेंगे।
चरण 1) हम अंश बनाते हैं, जो x – min(x) होता है। R में, हम अंश को इस तरह एक वेरिएबल में स्टोर कर सकते हैं:
nominator <- x-min(x)
चरण 2) हम हर की गणना करते हैं: max(x) – min(x)। हम चरण 1 के विचार को दोहरा सकते हैं और गणना को एक चर में संग्रहीत कर सकते हैं:
denominator <- max(x)-min(x)
चरण 3) हम नामांकक और हर के बीच विभाजन करते हैं।
normalize <- nominator/denominator
चरण 4) कॉलिंग फ़ंक्शन को मान लौटाने के लिए हमें फ़ंक्शन का आउटपुट प्राप्त करने के लिए return() के अंदर normalize पास करना होगा।
return(normalize)
चरण 5) हम रैप द्वारा फ़ंक्शन का उपयोग करने के लिए तैयार हैंping ब्रैकेट के अंदर सब कुछ।
normalize <- function(x){ # step 1: create the nominator nominator <- x-min(x) # step 2: create the denominator denominator <- max(x)-min(x) # step 3: divide nominator by denominator normalize <- nominator/denominator # return the value return(normalize) }
आइए चर c1 के साथ अपने फ़ंक्शन का परीक्षण करें:
normalize(data_frame$c1)
यह पूरी तरह से काम करता है। हमने अपना पहला फ़ंक्शन बनाया।
किसी दोहराए जाने वाले कार्य को करने का एक अधिक व्यापक तरीका फंक्शन है। हम अलग-अलग कॉलम पर नॉर्मलाइज़ फ़ॉर्मूला का उपयोग कर सकते हैं, जैसा कि नीचे दिखाया गया है:
data_frame$c1_norm_function <- normalize (data_frame$c1) data_frame$c2_norm_function <- normalize (data_frame$c2) data_frame$c3_norm_function <- normalize (data_frame$c3)
उदाहरण सरल होते हुए भी, हम सूत्र की शक्ति का अनुमान लगा सकते हैं। उपरोक्त कोड पढ़ने में आसान है और कोड पेस्ट करने से होने वाली गलतियों से बचाता है।
शर्त के साथ कार्य
normalize() फ़ंक्शन हमेशा एक ही काम करता है। कभी-कभी, हमें फ़ंक्शन में शर्तें शामिल करने की आवश्यकता होती है ताकि कोड अलग-अलग आउटपुट दे सके।
मशीन लर्निंग कार्यों में, हमें डेटासेट को ट्रेन सेट और टेस्ट सेट के बीच विभाजित करने की आवश्यकता होती है। ट्रेन सेट एल्गोरिदम को डेटा से सीखने की अनुमति देता है। अपने मॉडल के प्रदर्शन का परीक्षण करने के लिए, हम प्रदर्शन माप को वापस करने के लिए परीक्षण सेट का उपयोग कर सकते हैं। R में दो डेटासेट बनाने के लिए कोई फ़ंक्शन नहीं है। हम ऐसा करने के लिए अपना स्वयं का फ़ंक्शन लिख सकते हैं। हमारा फ़ंक्शन दो तर्क लेता है और इसे split_data() कहा जाता है। इसके पीछे का विचार सरल है, हम डेटासेट की लंबाई (यानी अवलोकनों की संख्या) को 0.8 से गुणा करते हैं। उदाहरण के लिए, यदि हम डेटासेट को 80/20 से विभाजित करना चाहते हैं, और हमारे डेटासेट में 100 पंक्तियाँ हैं, तो हमारा फ़ंक्शन 0.8*100 = 80 को गुणा करेगा। 80 पंक्तियाँ हमारे प्रशिक्षण डेटा बनने के लिए चुनी जाएँगी।
हम अपने उपयोगकर्ता-परिभाषित फ़ंक्शन का परीक्षण करने के लिए एयरक्वालिटी डेटासेट का उपयोग करेंगे। एयरक्वालिटी डेटासेट में 153 पंक्तियाँ हैं। हम इसे नीचे दिए गए कोड से देख सकते हैं:
nrow(airquality)
आउटपुट:
## [1] 153
हम निम्नानुसार आगे बढ़ेंगे:
split_data <- function(df, train = TRUE) Arguments: -df: Define the dataset -train: Specify if the function returns the train set or test set. By default, set to TRUE
हमारे फ़ंक्शन में दो तर्क हैं। तर्क ट्रेन एक बूलियन पैरामीटर है। यदि इसे TRUE पर सेट किया जाता है, तो हमारा फ़ंक्शन ट्रेन डेटासेट बनाता है, अन्यथा, यह परीक्षण डेटासेट बनाता है।
हम normalize() फ़ंक्शन की तरह ही आगे बढ़ सकते हैं। हम कोड को ऐसे लिखते हैं जैसे कि यह केवल एक बार का कोड हो और फिर फ़ंक्शन बनाने के लिए शर्त सहित सभी चीज़ों को बॉडी में लपेट देते हैं।
चरण १:
हमें डेटासेट की लंबाई की गणना करने की आवश्यकता है। यह nrow() फ़ंक्शन के साथ किया जाता है। Nrow डेटासेट में पंक्तियों की कुल संख्या लौटाता है। हम चर को लंबाई कहते हैं।
length<- nrow(airquality) length
आउटपुट:
## [1] 153
चरण १:
हम लंबाई को 0.8 से गुणा करते हैं। यह चयन करने के लिए पंक्तियों की संख्या लौटाएगा। यह 153*0.8 = 122.4 होना चाहिए
total_row <- length*0.8 total_row
आउटपुट:
## [1] 122.4
हम एयरक्वालिटी डेटासेट में 122 पंक्तियों में से 153 पंक्तियों का चयन करना चाहते हैं। हम 1 से लेकर total_row तक के मानों वाली एक सूची बनाते हैं। हम परिणाम को split नामक वेरिएबल में संग्रहीत करते हैं
split <- 1:total_row split[1:5]
आउटपुट:
## [1] 1 2 3 4 5
स्प्लिट डेटासेट से पहली 122 पंक्तियाँ चुनता है। उदाहरण के लिए, हम देख सकते हैं कि हमारा वैरिएबल स्प्लिट 1, 2, 3, 4, 5 और इसी तरह के मानों को इकट्ठा करता है। जब हम रिटर्न करने के लिए पंक्तियाँ चुनेंगे तो ये मान इंडेक्स होंगे।
चरण १:
हमें स्प्लिट वैरिएबल में संग्रहीत मानों के आधार पर एयरक्वालिटी डेटासेट में पंक्तियों का चयन करना होगा। यह इस तरह किया जाता है:
train_df <- airquality[split, ] head(train_df)
आउटपुट:
##[1] Ozone Solar.R Wind Temp Month Day ##[2] 51 13 137 10.3 76 6 20 ##[3] 15 18 65 13.2 58 5 15 ##[4] 64 32 236 9.2 81 7 3 ##[5] 27 NA NA 8.0 57 5 27 ##[6] 58 NA 47 10.3 73 6 27 ##[7] 44 23 148 8.0 82 6 13
चरण १:
हम शेष पंक्तियों, 123:153 का उपयोग करके परीक्षण डेटासेट बना सकते हैं। यह split के सामने – का उपयोग करके किया जाता है।
test_df <- airquality[-split, ] head(test_df)
आउटपुट:
##[1] Ozone Solar.R Wind Temp Month Day ##[2] 123 85 188 6.3 94 8 31 ##[3] 124 96 167 6.9 91 9 1 ##[4] 125 78 197 5.1 92 9 2 ##[5] 126 73 183 2.8 93 9 3 ##[6] 127 91 189 4.6 93 9 4 ##[7] 128 47 95 7.4 87 9 5
चरण १:
हम फ़ंक्शन के मुख्य भाग के अंदर शर्त बना सकते हैं। याद रखें, हमारे पास एक तर्क ट्रेन है जो ट्रेन सेट को वापस करने के लिए डिफ़ॉल्ट रूप से TRUE पर सेट एक बूलियन है। शर्त बनाने के लिए, हम if सिंटैक्स का उपयोग करते हैं:
if (train ==TRUE){ train_df <- airquality[split, ] return(train) } else { test_df <- airquality[-split, ] return(test) }
बस इतना ही, हम फ़ंक्शन लिख सकते हैं। हमें केवल airquality को df में बदलने की ज़रूरत है क्योंकि हम अपने फ़ंक्शन को किसी भी पर आज़माना चाहते हैं डेटा ढांचा, न केवल वायु गुणवत्ता:
split_data <- function(df, train = TRUE){ length<- nrow(df) total_row <- length *0.8 split <- 1:total_row if (train ==TRUE){ train_df <- df[split, ] return(train_df) } else { test_df <- df[-split, ] return(test_df) } }
आइए, वायु गुणवत्ता डेटासेट पर अपने फ़ंक्शन को आज़माते हैं। हमारे पास 122 पंक्तियों वाला एक प्रशिक्षण सेट और 31 पंक्तियों वाला एक परीक्षण सेट होना चाहिए।
train <- split_data(airquality, train = TRUE)
dim(train)
आउटपुट:
## [1] 122 6
test <- split_data(airquality, train = FALSE)
dim(test)
आउटपुट:
## [1] 31 6
