आर प्रोग्रामिंग में कार्य (उदाहरण के साथ)

विषय - सूची:

Anonim

R में एक फंक्शन क्या है?

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

एक फंक्शन होना चाहिए

  • एक निर्दिष्ट कार्यों को पूरा करने के लिए लिखा गया है
  • तर्कों को शामिल किया जा सकता है या नहीं
  • एक शरीर होता है
  • एक या एक से अधिक मान वापस कर सकते हैं या नहीं।

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

function (arglist) {#Function body}

इस ट्यूटोरियल में हम सीखेंगे

  • महत्वपूर्ण अंतर्निहित कार्य
  • सामान्य कार्य
  • गणित के कार्य
  • सांख्यिकीय कार्य
  • आर में फ़ंक्शन लिखें
  • हमें फ़ंक्शन कब लिखना चाहिए?
  • शर्त के साथ कार्य

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

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

नोट : फ़ंक्शन का नाम कंसोल में स्वयं चलाकर किसी फ़ंक्शन के स्रोत कोड को देखना संभव है।

हम कार्रवाई में फ़ंक्शन के तीन समूह देखेंगे

  • सामान्य कार्य
  • गणित समारोह
  • सांख्यिकीय समारोह

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

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

diff () फ़ंक्शन

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

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

set.seed(123)## Create the datax = rnorm(1000)ts <- cumsum(x)## Stationary the seriediff_ts <- diff(ts)par(mfrow=c(1,2))## Plot the seriesplot(ts,)plot(diff(ts),)

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

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

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

dt <- cars## number columnslength(dt)

आउटपुट:

## [1] 1
## number rowslength(dt[,1])

आउटपुट:

## [1] 50

गणित के कार्य

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

ऑपरेटर विवरण
एब्स (x) X का पूर्ण मान लेता है
लॉग (x, आधार = y) बेस y के साथ x का लघुगणक लेता है; यदि आधार निर्दिष्ट नहीं है, तो प्राकृतिक लघुगणक लौटाता है
ऍक्स्प (x) एक्स का घातांक लौटाता है
sqrt (x) X का वर्गमूल देता है
भाज्य (x) एक्स (एक्स!) के भाज्य लौटाता है 
# sequence of number from 44 to 55 both including incremented by 1x_vector <- seq(45,55, by = 1)#logarithmlog(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
#exponentialexp(x_vector)
#squared rootsqrt(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
#factorialfactorial(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

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

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

मूल सांख्यिकीय कार्य

ऑपरेटर

विवरण

माध्य (x)

एक्स का मतलब

मध्य (x)

एक्स का माध्यिका

var (x)

एक्स का भिन्न

एसडी (एक्स)

X का मानक विचलन

स्केल (x)

एक्स के मानक स्कोर (जेड-स्कोर)

मात्रात्मक (x)

एक्स के चतुर्थांश

सारांश (x)

एक्स का सारांश: मतलब, न्यूनतम, अधिकतम आदि ...

 
speed <- dt$speedspeed# Mean speed of cars datasetmean(speed)

आउटपुट:

## [1] 15.4
# Median speed of cars datasetmedian(speed)

आउटपुट:

## [1] 15
# Variance speed of cars datasetvar(speed)

आउटपुट:

## [1] 27.95918
# Standard deviation speed of cars datasetsd(speed)

आउटपुट:

## [1] 5.287644
# Standardize vector speed of cars datasethead(scale(speed), 5)

आउटपुट:

## [,1]## [1,] -2.155969## [2,] -2.155969## [3,] -1.588609## [4,] -1.588609## [5,] -1.399489
# Quantile speed of cars datasetquantile(speed)

आउटपुट:

## 0% 25% 50% 75% 100%## 4 12 15 19 25
# Summary speed of cars datasetsummary(speed)

आउटपुट:

## Min. 1st Qu. Median Mean 3rd Qu. Max.## 4.0 12.0 15.0 15.4 19.0 25.0

इस बिंदु तक, हमने बहुत सारे आर-निर्मित कार्यों को सीखा है।

नोट : तर्क के वर्ग, यानी संख्यात्मक, बूलियन या स्ट्रिंग के साथ सावधान रहें। उदाहरण के लिए, यदि हमें एक स्ट्रिंग मान पास करने की आवश्यकता है, तो हमें स्ट्रिंग को उद्धरण चिह्न: "एबीसी" में संलग्न करना होगा।

आर में फ़ंक्शन लिखें

किसी अवसर में, हमें अपना स्वयं का फ़ंक्शन लिखना होगा क्योंकि हमें एक विशेष कार्य पूरा करना है और कोई भी तैयार फ़ंक्शन मौजूद नहीं है। उपयोगकर्ता-परिभाषित फ़ंक्शन में एक नाम , तर्क और एक निकाय शामिल होता है ।

function.name <- function(arguments){computations on the argumentssome other code}

नोट : उपयोगकर्ता द्वारा परिभाषित फ़ंक्शन को एक अंतर्निहित फ़ंक्शन से अलग करने के लिए एक अच्छा अभ्यास है। यह भ्रम से बचा जाता है।

एक तर्क समारोह

अगले स्निपेट में, हम एक साधारण वर्ग फ़ंक्शन को परिभाषित करते हैं। फ़ंक्शन मान स्वीकार करता है और मान का वर्ग लौटाता है।

square_function<- function(n){# compute the square of integer `n`n^2}# calling the function and passing value 4square_function(4)

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

  • फ़ंक्शन को स्क्वायर_फंक्शन नाम दिया गया है; इसे हम जो चाहें कह सकते हैं।
  • यह एक तर्क "एन" प्राप्त करता है। हमने चर के प्रकार को निर्दिष्ट नहीं किया है ताकि उपयोगकर्ता एक पूर्णांक, एक वेक्टर या मैट्रिक्स पास कर सके
  • फ़ंक्शन इनपुट "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 फ़ंक्शन का तर्क इस वैश्विक वातावरण में नहीं है ।

प्रत्येक फ़ंक्शन के लिए एक नया वातावरण बनाया जाता है। उपरोक्त उदाहरण में, फ़ंक्शन square_function () वैश्विक वातावरण के अंदर एक नया वातावरण बनाता है।

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

ये फ़ंक्शन एक मान के रूप में x लेता है और फ़ंक्शन के बाहर और अंदर y परिभाषित करने के लिए इसे जोड़ता है

फ़ंक्शन एफ आउटपुट 15 लौटाता है। ऐसा इसलिए है क्योंकि y को वैश्विक वातावरण में परिभाषित किया गया है। वैश्विक वातावरण में परिभाषित किसी भी चर का स्थानीय स्तर पर उपयोग किया जा सकता है। चर y में सभी फ़ंक्शन कॉल के दौरान 10 का मान है और किसी भी समय सुलभ है।

आइए देखें कि फ़ंक्शन के अंदर चर y को परिभाषित करने पर क्या होता है।

हमें rm r का उपयोग करके इस कोड को चलाने से पहले `y` को ड्राप करना होगा

जब हम f (5) कहते हैं तो आउटपुट भी 15 होता है, लेकिन जब हम वैल्यू y को प्रिंट करने की कोशिश करते हैं तो एक त्रुटि होती है। चर y वैश्विक वातावरण में नहीं है।

अंत में, R किसी फ़ंक्शन के शरीर के अंदर से गुजरने के लिए सबसे हाल की परिवर्तनीय परिभाषा का उपयोग करता है। आइए निम्नलिखित उदाहरण पर विचार करें:

R फ़ंक्शन के बाहर परिभाषित y मानों को अनदेखा करता है क्योंकि हमने फ़ंक्शन के शरीर के अंदर स्पष्ट रूप से ay चर बनाया है।

बहु तर्क कार्य

हम एक से अधिक तर्क वाले फ़ंक्शन लिख सकते हैं। "समय" नामक फ़ंक्शन पर विचार करें। यह एक सीधा कार्य है जो दो चर का गुणा करता है।

times <- function(x,y) {x*y}times(2,4)

आउटपुट:

## [1] 8

हमें फ़ंक्शन कब लिखना चाहिए?

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

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

library(tibble)# Create a data framedata_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 के साथ फ़ंक्शन का विवरण:

Nominator:: data_frame $ c1 -मिन (data_frame $ c1))

इनकार: अधिकतम (data_frame $ c1) -min (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 c1data_frame$c1_norm <- (data_frame$c1 -min(data_frame$c1))/(max(data_frame$c1)-min(data_frame$c1))# show the first five valueshead(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)

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

normalize <- function(x){# step 1: create the nominatornominator <- x-min(x)# step 2: create the denominatordenominator <- max(x)-min(x)# step 3: divide nominator by denominatornormalize <- nominator/denominator# return the valuereturn(normalize)}

चलो चर 1 के साथ हमारे फ़ंक्शन का परीक्षण करें:

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

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

चरण 1:

हमें डाटासेट की लंबाई की गणना करने की आवश्यकता है। यह फ़ंक्शन nrow () के साथ किया जाता है। डेटासेट में पंक्तियों की कुल संख्या Nrow लौटाती है। हम चर लंबाई कहते हैं।

length<- nrow(airquality)length

आउटपुट:

## [1] 153

चरण 2:

हम लंबाई को 0.8 से गुणा करते हैं। यह चयन करने के लिए पंक्तियों की संख्या लौटाएगा। यह 153 * 0.8 = 122.4 होना चाहिए

total_row <- length*0.8total_row

आउटपुट:

## [1] 122.4

हम वायुरोधी डेटासेट में 153 पंक्तियों के बीच 122 पंक्तियों का चयन करना चाहते हैं। हम एक सूची बनाते हैं, जिसमें मान 1 से लेकर total_row तक हैं हम परिणाम को चर में विभाजित करते हैं जिसे स्प्लिट कहते हैं

split <- 1:total_rowsplit[1:5]

आउटपुट:

## [1] 1 2 3 4 5

विभाजन डेटासेट से पहली 122 पंक्तियों को चुनता है। उदाहरण के लिए, हम देख सकते हैं कि हमारा वैरिएबल स्प्लिट 1, 2, 3, 4, 5 वगैरह को इकट्ठा करता है। ये मान सूचकांक होंगे जब हम लौटने के लिए पंक्तियों का चयन करेंगे।

चरण 3:

हमें विभाजित चर में संग्रहीत मानों के आधार पर एयरक्विटी डेटासेट में पंक्तियों का चयन करना होगा। यह इस प्रकार किया जाता है:

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

चरण 4:

हम शेष पंक्तियों, 123: 153 का उपयोग करके परीक्षण डेटासेट बना सकते हैं। यह विभाजन के सामने - का उपयोग करके किया जाता है।

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

चरण 5:

हम फ़ंक्शन के शरीर के अंदर की स्थिति बना सकते हैं। याद रखें, हमारे पास एक तर्क ट्रेन है जो ट्रेन सेट को वापस करने के लिए डिफ़ॉल्ट रूप से TRUE के लिए एक बूलियन सेट है। स्थिति बनाने के लिए, हम सिंटैक्स का उपयोग करते हैं:

if (train ==TRUE){train_df <- airquality[split, ]return(train)} else {test_df <- airquality[-split, ]return(test)}

यह वह है, हम फ़ंक्शन लिख सकते हैं। हमें केवल df के लिए airquality को बदलने की आवश्यकता है क्योंकि हम अपने कार्य को किसी भी डेटा फ्रेम में आज़माना चाहते हैं, न कि केवल airquality:

split_data <- function(df, train = TRUE){length<- nrow(df)total_row <- length *0.8split <- 1:total_rowif (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