उदाहरण के साथ आर प्रोग्रामिंग में फ़ंक्शन

आर में फ़ंक्शन क्या है?

A समारोहप्रोग्रामिंग वातावरण में, निर्देशों का एक सेट है। एक प्रोग्रामर किसी फ़ंक्शन का निर्माण करता है ताकि वह किसी भी तरह की परेशानी से बच सके। दोहराते हुए वही कार्य करें, या कम करें जटिलता।

एक समारोह होना चाहिए

• किसी निर्दिष्ट कार्य को पूरा करने के लिए लिखा गया
• इसमें तर्क शामिल हो भी सकते हैं और नहीं भी
• एक शरीर शामिल
• एक या अधिक मान लौटा सकता है या नहीं भी लौटा सकता है.

किसी फ़ंक्शन के लिए एक सामान्य दृष्टिकोण तर्क भाग का उपयोग करना है निविष्टियां, खिलाओ परिवर्तन भाग और अंत में वापसी उत्पादनफ़ंक्शन का सिंटैक्स निम्नलिखित है:

function (arglist)  {
  #Function body
}

आर महत्वपूर्ण अंतर्निहित कार्य

R में बहुत सारे बिल्ट-इन फ़ंक्शन हैं। R आपके इनपुट पैरामीटर को अपने फ़ंक्शन तर्कों से, या तो मान या स्थिति के आधार पर, मैच करता है, फिर फ़ंक्शन बॉडी को निष्पादित करता है। फ़ंक्शन तर्कों में डिफ़ॉल्ट मान हो सकते हैं: यदि आप इन तर्कों को निर्दिष्ट नहीं करते हैं, तो R डिफ़ॉल्ट मान लेगा।
नोट:
कंसोल में फ़ंक्शन का नाम चलाकर फ़ंक्शन का स्रोत कोड देखना संभव है।

हम कार्य के तीन समूहों को क्रियाशील देखेंगे

• सामान्य कार्य
• गणित फ़ंक्शन
• सांख्यिकीय कार्य

सामान्य कार्य

हम पहले से ही cbind(), rbind(),range(),sort(),order() फ़ंक्शन जैसे सामान्य फ़ंक्शन से परिचित हैं। इनमें से प्रत्येक फ़ंक्शन का एक विशिष्ट कार्य होता है, आउटपुट वापस करने के लिए तर्क लेता है। निम्नलिखित महत्वपूर्ण फ़ंक्शन हैं जिन्हें आपको अवश्य जानना चाहिए-

diff() फ़ंक्शन

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

नोट: हमें अक्सर यादृच्छिक डेटा बनाने की आवश्यकता होती है, लेकिन सीखने और तुलना के लिए हम चाहते हैं कि संख्याएँ सभी मशीनों में समान हों। यह सुनिश्चित करने के लिए कि हम सभी एक ही डेटा उत्पन्न करते हैं, हम 123 के मनमाने मूल्यों के साथ set.seed() फ़ंक्शन का उपयोग करते हैं। 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')

लंबाई() फ़ंक्शन

कई मामलों में, हम जानना चाहते हैं लंबाई गणना के लिए या फ़ॉर लूप में उपयोग किए जाने वाले वेक्टर का। लंबाई() फ़ंक्शन वेक्टर x में पंक्तियों की संख्या गिनता है। निम्नलिखित कोड कारों के डेटासेट को आयात करते हैं और पंक्तियों की संख्या लौटाते हैं।

नोट: लंबाई() एक वेक्टर में तत्वों की संख्या लौटाता है। यदि फ़ंक्शन को मैट्रिक्स या डेटा फ़्रेम में पास किया जाता है, तो कॉलम की संख्या लौटाई जाती है।

dt <- cars
## number columns
length(dt)

आउटपुट:

## [1] 1

## number rows
length(dt[,1])

आउटपुट:

## [1] 50

गणित के कार्य

आर में गणितीय कार्यों की एक सरणी है।

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

सांख्यिकीय कार्य

आर मानक स्थापना में सांख्यिकीय कार्यों की विस्तृत श्रृंखला शामिल है। इस ट्यूटोरियल में, हम संक्षेप में सबसे महत्वपूर्ण फ़ंक्शन को देखेंगे।

बुनियादी सांख्यिकी कार्य

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)

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

• इस फ़ंक्शन का नाम square_function है; इसे हम जो चाहें कह सकते हैं।
• इसे एक तर्क “n” प्राप्त होता है। हम चर का प्रकार निर्दिष्ट नहीं किया गया ताकि उपयोगकर्ता पूर्णांक, सदिश या मैट्रिक्स पास कर सके
• फ़ंक्शन इनपुट “n” लेता है और इनपुट का वर्ग लौटाता है। जब आप फ़ंक्शन का उपयोग कर लेते हैं, तो हम इसे rm() फ़ंक्शन से हटा सकते हैं।

# फ़ंक्शन बनाने के बाद

rm(square_function)
square_function

कंसोल पर, हम एक त्रुटि संदेश देख सकते हैं: त्रुटि: ऑब्जेक्ट 'square_function' नहीं मिला, जो बताता है कि फ़ंक्शन मौजूद नहीं है।

पर्यावरण स्कोपिंग

आर में, वातावरण एक संग्रह फ़ंक्शन, वेरिएबल्स, डेटा फ़्रेम आदि जैसी वस्तुओं का।

प्रत्येक बार जब Rstudio को संकेत दिया जाता है तो R एक वातावरण खोलता है।

उपलब्ध शीर्ष-स्तरीय वातावरण है वैश्विक पर्यावरण, जिसे R_GlobalEnv कहा जाता है। और हमारे पास है स्थानीय पर्यावरण।

हम वर्तमान परिवेश की सामग्री को सूचीबद्ध कर सकते हैं।

ls(environment())

उत्पादन

## [1] "diff_ts"         "dt"              "speed"           "square_function"
## [5] "ts"              "x"               "x_vector"

आप R_GlobalEnv में बनाए गए सभी वेरिएबल्स और फ़ंक्शन देख सकते हैं।

उपरोक्त सूची आपके द्वारा R स्टूडियो में निष्पादित ऐतिहासिक कोड के आधार पर भिन्न होगी।

ध्यान दें कि n, square_function फ़ंक्शन का तर्क है इस वैश्विक वातावरण में नहीं.

A नई प्रत्येक फ़ंक्शन के लिए एक नया वातावरण बनाया जाता है। उपरोक्त उदाहरण में, फ़ंक्शन 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) हम बनाते हैं नामजद करने, जो है। R में, हम नॉमिनेटर को इस तरह एक चर में संग्रहीत कर सकते हैं:

nominator <- x-min(x)

चरण 2) हम गणना करते हैं हर: हम चरण 1 के विचार को दोहरा सकते हैं और गणना को एक चर में संग्रहीत कर सकते हैं:

denominator <- max(x)-min(x)

चरण 3) हम नामांकक और हर के बीच विभाजन करते हैं।

normalize <- nominator/denominator

चरण 4) कॉलिंग फ़ंक्शन को मान लौटाने के लिए हमें फ़ंक्शन का आउटपुट प्राप्त करने के लिए return() के अंदर normalize पास करना होगा।

return(normalize)

चरण 5) हम सब कुछ ब्रैकेट के अंदर लपेटकर फ़ंक्शन का उपयोग करने के लिए तैयार हैं।

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)

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

शर्त के साथ कार्य

कभी-कभी, कोड को अलग-अलग आउटपुट देने की अनुमति देने के लिए हमें फ़ंक्शन में शर्तें शामिल करने की आवश्यकता होती है।

मशीन लर्निंग कार्यों में, हमें डेटासेट को ट्रेन सेट और टेस्ट सेट के बीच विभाजित करने की आवश्यकता होती है। ट्रेन सेट एल्गोरिदम को डेटा से सीखने की अनुमति देता है। अपने मॉडल के प्रदर्शन का परीक्षण करने के लिए, हम प्रदर्शन माप को वापस करने के लिए परीक्षण सेट का उपयोग कर सकते हैं। 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 पर सेट किया जाता है, तो हमारा फ़ंक्शन ट्रेन डेटासेट बनाता है, अन्यथा, यह परीक्षण डेटासेट बनाता है।

हम वैसे ही आगे बढ़ सकते हैं जैसे हमने normalise() फ़ंक्शन के साथ किया था। हम कोड को ऐसे लिखते हैं जैसे कि यह सिर्फ़ एक बार का कोड हो और फिर फ़ंक्शन बनाने के लिए शर्त के साथ सब कुछ बॉडी में लपेट देते हैं।

चरण १:

हमें डेटासेट की लंबाई की गणना करने की आवश्यकता है। यह 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