एंबेडेड मोड में आर स्क्रिप्ट चलाने से निम्नलिखित क्षमताएं मिलती हैं:
- R उपयोगकर्ताओं को मानक R अनुप्रयोगों के साथ-साथ SQL का उपयोग करने वाले अनुप्रयोगों में मौजूदा R स्क्रिप्ट चलाने की अनुमति देता है
- आर स्क्रिप्ट डेटा के "बगल" में लॉन्च की जाती हैं। इन स्क्रिप्ट में CRAN रिपॉजिटरी से मानक पैकेज और विस्तारित पैकेज दोनों शामिल हो सकते हैं
- DBMS में काम करने से आप उपयोगकर्ता-नियंत्रित या DBMS-नियंत्रित समानता का उपयोग कर सकते हैं
यह मोड बहुत लचीला है और इसे Oracle DBMS इंजन फ़ंक्शंस में R फ़ंक्शंस के पारदर्शी पुनर्लेखन का उपयोग करके और भी अनुकूलित किया जा सकता है।
एंबेड आर-एसक्यूएल एपीआई में एक्सएमएल जेनरेशन का उपयोग करके, आप आर में ग्राफ़ बना सकते हैं और अपने काम के परिणामों को ओबीआईईई पैनल और प्रकाशक दस्तावेज़ों में एम्बेड कर सकते हैं।
मानक आर वातावरण से एंबेडेड आर चलाने के लिए कार्य
Oracle ने ORE पैकेज में कई फ़ंक्शन विकसित किए हैं जो आपको तैयार स्क्रिप्ट लेने और निष्पादन के लिए DBMS में स्थानांतरित करने की अनुमति देते हैं।
एंबेडेड आर के लिए आर इंटरफ़ेस आपको न केवल आर स्क्रिप्ट को डेटाबेस के करीब चलाने की अनुमति देता है, बल्कि उन्हें एसक्यूएल इंटरफ़ेस में एम्बेड करने से पहले इंटरैक्टिव रूप से परीक्षण भी करता है।
एंबेडेड आर के लिए आर इंटरफ़ेस में निम्नलिखित कार्यों का सेट शामिल है (प्रत्येक अपनी स्थिति में उपयोगी है):
| अयस्क.doEval() | डेटाबेस में पारित आर स्क्रिप्ट को चलाता है और इनपुट या पैरामीटर को पारित करने की अनुमति नहीं देता है। यह बस एक अयस्क.फ़्रेम या क्रमबद्ध आर ऑब्जेक्ट लौटाता है |
| अयस्क.टेबललागू करें() | इनपुट के रूप में एक तालिका (ore.frame) प्राप्त होती है, जो पूरी तरह से फ़ंक्शन इनपुट में फीड की जाती है। doEval() की तरह यह एक अयस्क.फ़्रेम या क्रमबद्ध R ऑब्जेक्ट लौटा सकता है |
| अयस्क.rowलागू करें() | आपको उन पंक्तियों की संख्या निर्दिष्ट करने की अनुमति देता है जिनके साथ फ़ंक्शन काम करेगा (खंड आकार)। यदि डीबीएमएस में कई आर इंजन चलाने की अनुमति दी जाती है तो फ़ंक्शन को कई प्रक्रियाओं द्वारा समानांतर में बुलाया जाता है। परिणाम प्रत्येक भाग के लिए परिणामों की एक सूची है। |
| अयस्क.समूहलागू करें() | आपूर्ति किए गए डेटा को संबंधित कॉलम के मानों के अनुसार भागों में विभाजित करता है, और फिर प्रत्येक अनुभाग के लिए आपूर्ति की गई आर स्क्रिप्ट को समानांतर में चलाता है। परिणाम प्रत्येक अद्वितीय कॉलम मान के लिए परिणामों की एक सूची है। |
| अयस्क.सूचकांकलागू() | ???? |
| अयस्क.स्क्रिप्टक्रिएट() | DBMS रिपॉजिटरी में एक नामित R स्क्रिप्ट बनाता है। इन नामित स्प्राइट्स का उपयोग आर एंबेडेड मोड में चल रही अन्य आर स्क्रिप्ट्स में किया जा सकता है |
| अयस्क.स्क्रिप्टड्रॉप() | नामित R स्क्रिप्ट को हटाता है |
DoEval के साथ सरल उदाहरण
आइए लिखें एक सरल आर प्रोग्राम. यह एक आयामी सरणी (आर शब्दों में वेक्टर) बनाएगा। वेक्टर में 1 से 10 तक की संख्याएँ होंगी, फिर एक तालिका बनाई जाएगी (आर के संदर्भ में फ्रेम), जिसमें पहले कॉलम में बनाए गए वेक्टर के मान होंगे, और दूसरे कॉलम में वही मान होंगे मान को 10 से विभाजित करें। R में यह इस प्रकार होगा:
पहचान<- seq(10)
फ़्रेम1<- data.frame(id = id, res = id / 10)
कार्य का परिणाम होगा
ORE>फ़्रेम1
आईडी रेस
1 1 0.1
2 2 0.2
3 3 0.3
4 4 0.4
5 5 0.5
6 6 0.6
7 7 0.7
8 8 0.8
9 9 0.9
10 10 1.0
अब हम यह सब एक फ़ंक्शन में लपेटते हैं और इसे doEval में कॉल करते हैं:
फ़्रेम1<- ore.doEval(
फलन (संख्या = 10, पैमाना = 10)
{
पहचान<- seq(num)
डेटा.फ़्रेम(आईडी = आईडी, रेस = आईडी/स्केल)
}
)
परिणाम वही होगा, लेकिन फ़ंक्शन सर्वर साइड पर लॉन्च किया जाएगा। उसी समय, सर्वर साइड पर नियमित आर लॉन्च किया जाता है, जो वास्तव में ओरेकल के बारे में कुछ नहीं जानता है।
पिछले उदाहरण में हमने जेनरेटेड डेटा का उपयोग किया था। यह बहुत दिलचस्प नहीं है. इस उदाहरण में, हम देखेंगे कि Oracle से डेटा कैसे लोड करें। यह ORE पैकेज का उपयोग करके किया जाता है। फिर हम भविष्यवाणियाँ करने के लिए रैखिक प्रतिगमन लागू करेंगे। यदि हम आर पर्यावरण पक्ष पर स्क्रिप्ट चला रहे थे, तो यह इस तरह होगा:
पुस्तकालय(ओआरई)
डैट<- ore.pull(ONTIME_S)
आधुनिक<- lm(ARRDELAY ~ DISTANCE + DEPDELAY, dat)
हम इसे एक फ़ंक्शन में लपेटते हैं और इसे इनपुट के रूप में doEval में पास करते हैं:
आधुनिक<- ore.doEval(
समारोह()
{
पुस्तकालय(ओआरई)
अयस्क.कनेक्ट (उपयोगकर्ता = "RUSER", sid = "orcl", होस्ट = "aryndin-ru", पासवर्ड = "oracle", सभी = TRUE)
डैट<- ore.pull(ONTIME_S)
lm(ARRDELAY ~ DISTANCE + DEPDELAY, dat)
});
mod_local<-ore.pull(mod)
अयस्क का उपयोग करें। तालिका लागू करें
TableApply फ़ंक्शन का उपयोग आमतौर पर तब किया जाता है जब हमें डेटा की संपूर्ण मात्रा पर एक मॉडल बनाने की आवश्यकता होती है।
आइए जीएलएम रिग्रेशन मॉडल का उपयोग करके एक उदाहरण लें। नियमित आर में यह इस तरह दिखेगा:
अयस्क.कनेक्ट (उपयोगकर्ता = "RUSER", sid = "orcl", होस्ट = "aryndin-ru", पासवर्ड = "oracle", सभी = TRUE)
एक्स<- ore.pull(ONTIME_S[,c("ARRDELAY","DISTANCE","DEPDELAY")])
आधुनिक<- glm(ARRDELAY ~ DISTANCE + DEPDELAY, data=x, family=gaussian())
हमारा कार्य डेटाबेस (ore.connect) से जुड़ना और ONTIME_S तालिका से कॉलम "ARRDELAY", "DISTANCE", "DEPDELAY" लेना है। फिर हम बस गाऊसी फ़ंक्शन के साथ जीएलएम रिग्रेशन मॉडल एल्गोरिदम को कॉल करते हैं।
Oracle R Enterprise के मामले में, हम पैरामीटर के माध्यम से कुछ मान (तालिका और फ़ंक्शन) पास करेंगे:
modCoef<- ore.tableApply(
ONTIME_S[,c("ARRDELAY","DISTANCE","DEPDELAY")],
परिवार = गाऊसी (),
फ़ंक्शन(x, परिवार) (
आधुनिक<- glm(ARRDELAY ~ DISTANCE + DEPDELAY,
डेटा=एक्स, परिवार=परिवार)
});
आइये जानें क्या हो रहा है. सबसे पहले, हम 3 कॉलम चुनते हैं जिन्हें एल्गोरिदम में इनपुट के रूप में आपूर्ति की जाएगी (ONTIME_S[,c('ARRDELAY','DISTANCE','DEPDELAY''])। इन्हें एक्स पैरामीटर के रूप में फ़ंक्शन में पास किया जाएगा। हम गाऊसी फ़ंक्शन भी निर्दिष्ट करते हैं। बाकी सब कुछ वैसा ही रहता है।
अयस्क का उपयोग करना। पंक्ति लागू करें
यदि पहले से निर्मित मॉडल को डेटा सेट (स्कोरिंग) पर लागू करने की आवश्यकता है तो rowApply फ़ंक्शन उपयोगी है। इस मामले में, हमें डेटा की पूरी मात्रा को मेमोरी में खींचने की ज़रूरत नहीं है, लेकिन बस पंक्ति-दर-पंक्ति प्रसंस्करण कर सकते हैं।
रैखिक प्रतिगमन के लिए नीचे एक काफी सरल उदाहरण दिया गया है। सबसे पहले, हम 5वें महीने के डेटा के आधार पर ARRDELAY कॉलम की भविष्यवाणी करने के लिए एक मॉडल बनाते हैं।
समय पर<- ore.pull(ONTIME_S)
आधुनिक<- lm(ARRDELAY ~ DISTANCE + DEPDELAY, data=ontime)
फिर हम एक अतिरिक्त PRED_DELAY कॉलम के साथ एक नया नया डेटा फ़्रेम बनाते हैं, जो पहले निर्मित मॉडल के पंक्ति-दर-पंक्ति (एक समय में 1000 पंक्तियाँ) एप्लिकेशन का उपयोग करके भरा जाता है:
ONTIME_S2<- ONTIME[,c("ARRDELAY","DEPDELAY","DISTANCE")]
ONTIME_S2$PRED_DELAY<- 0
आर ई<- ore.rowApply(ONTIME,
मॉड = मॉड,
फ़ंक्शन(डेट, मॉड) सीबाइंड(डेट, पूर्वानुमान(मॉड, डेटा)),
FUN.VALUE = ONTIME_S2, पंक्तियाँ=1000)
अयस्क का उपयोग करना। समूह लागू करें
यदि आपको एक ही प्रकार के कई डेटा मॉडल बनाने की आवश्यकता है तो ग्रुपएप्लाई फ़ंक्शन का उपयोग किया जाता है। और प्रत्येक मॉडल दूसरों के समानांतर बनाया गया है, लेकिन डेटा के अपने समूह के अनुसार।
एकाधिक मॉडल बनाने के लिए ग्रुपएप्लाई का उपयोग करने का एक उदाहरण नीचे दिया गया है। प्रत्येक मॉडल अपने स्वयं के हवाई अड्डे के लिए जिम्मेदार होगा (INDEX=ONTIME_S$DEST):
मॉडलिस्ट<- ore.groupApply(
ONTIME_S,
सूचकांक=ONTIME_S$DEST,
फ़ंक्शन(डेटा) (
पुस्तकालय(बिगएलएम)
biglm(ARRDELAY ~ DISTANCE + DEPDELAY, dat)
});
modList_local<- ore.pull(modList)
सारांश(modList_local$BOS) ## बीओएस के लिए रिटर्न मॉडल
ग्राफ़िक्स प्रस्तुत करने के लिए ORE का उपयोग करने का एक दिलचस्प उदाहरण
यह कमांड हमें Oracle डेटाबेस सर्वर साइड पर एक ग्राफ़ के साथ एक पीडीएफ दस्तावेज़ उत्पन्न करने के लिए एक आर फ़ंक्शन चलाने की अनुमति देता है
अयस्क.doEval(फ़ंक्शन() (
पीडीएफ(“c:/temp/my_file.pdf”)
सेट.बीज(25)
एक्स<- rchisq(1000, df = 3)
## मॉडल वितरण के साथ डेटा की तुलना करें
qqplot(x, qchisq(ppoints(x), df = 3));
एब्लाइन(0,1, col = 2, lty = 2)
इतिहास(x, आवृत्ति = गलत, ylim = c(0, 0.25))
वक्र(dchisq(x, df = 3), col = 2, lty = 2,
lwd = 2, जोड़ें = सत्य)
देव.ऑफ()
सत्य))
निम्नलिखित पीडीएफ दस्तावेज़ तैयार किया जाएगा:
निष्कर्ष
Oracle R Enterprise आपको डेटाबेस सर्वर साइड पर बिना किसी बदलाव के तैयार R स्क्रिप्ट चलाने की अनुमति देता है। यह निम्नलिखित मामलों में बहुत उपयोगी है:
- उपयोगकर्ता के कंप्यूटर में सर्वर की तुलना में कम मेमोरी होती है। यह मूल रूप से आपको बहुत बड़ी मात्रा में डेटा पर आर स्क्रिप्ट चलाने की अनुमति देता है।
- आर की गति में सुधार के लिए डेटाबेस की अंतर्निहित समानता का लाभ उठाना आवश्यक है।
- क्लाइंट पक्ष पर डेटा पुनर्प्राप्ति को बाहर करना आवश्यक है (सुरक्षा कारणों से या क्योंकि उपयोगकर्ता और डेटाबेस के बीच का चैनल धीमा है)।
अयस्क*अप्लाई फ़ंक्शंस का उपयोग करने के बारे में एकमात्र चीज़ जो मुझे वास्तव में पसंद नहीं आई, वह थी ख़राब दस्तावेज़ीकरण, लेकिन मुझे लगता है कि इसे ठीक कर दिया जाएगा।
एक वेरिएबल बनाने के लिए (उदाहरण के लिए, x) और उसे एक मान निर्दिष्ट करने के लिए (उदाहरण के लिए, 1234), आप बस कमांड x=1234 दर्ज करें। अब, किसी भी अभिव्यक्ति में, चर नाम (हमारे मामले में x) स्वचालित रूप से मान से बदल दिया जाएगा (हमारे लिए यह 1234 है)।
किसी वेरिएबल का मान जानने के लिए, बस वेरिएबल का नाम दर्ज करें, और R उसका मान लौटा देगा। यह इस तरह दिखेगा:
>x=1234
> एक्स
1234
किसी वेरिएबल को नया मान निर्दिष्ट करके, आप पुराने मान का उपयोग कर सकते हैं, अर्थात, जैसे निर्माण बना सकते हैं
>ए=5
> ए
5
>ए=ए+3
> ए
8
यह जानना महत्वपूर्ण है कि परिवर्तनीय नामों में दोनों मामलों, संख्याओं और अंडरस्कोर के लैटिन अक्षर शामिल हो सकते हैं (उदाहरण के लिए, निम्नलिखित नाम स्वीकार्य हैं: a, x, x1, a_x, O_o, the_Variable_with_Long_Name, a459x4h36J4lbgT62)। इस मामले में, पहला अक्षर एक अक्षर होना चाहिए! अंत में, मामला मायने रखता है, जिसका अर्थ है कि रेनफॉरेस्ट और रेनफॉरेस्ट अलग-अलग चर हैं।
वेक्टर, या डेटा श्रृंखला के साथ कैसे काम करें?
R में सदिश क्या हैं?
मान लीजिए कि हमारे पास 5 लोगों का एक समूह है, और हमें उनकी आयु बचाने की आवश्यकता है। उदाहरण के लिए, आप पाँच वेरिएबल बना सकते हैं
>उम्र_1=25
>उम्र_2=20
>उम्र_3=9
>उम्र_4=44
>उम्र_5=37
हालाँकि, एक वेरिएबल बनाना अधिक सुविधाजनक है जिसमें सभी 5 मान रखे जा सकें। डेटा की ऐसी श्रृंखला, एक नाम से एकजुट होकर, एक निश्चित क्रम में संग्रहीत एक डेटा सरणी या वेक्टर है।
असाइन करें("आयु",सी(25,20,9,44,37))
या संक्षिप्त: आयु
अब, प्रत्येक व्यक्तिगत तत्व को पंक्ति में उसके क्रमांक द्वारा बुलाया जा सकता है, उदाहरण के लिए, चौथा तत्व इस प्रकार प्राप्त किया जा सकता है:
>उम्र
44
ऐसे अलग-अलग तत्वों के साथ आप सामान्य संख्याओं के समान ही सभी कार्य कर सकते हैं
परिशिष्ट फ़ंक्शन, या किसी मौजूदा वेक्टर में तत्व कैसे जोड़ें?
मान लीजिए कि हमारे समूह में एक और व्यक्ति है जिसकी उम्र 31 वर्ष है। हम आयु वेक्टर को फिर से बना सकते हैं, लेकिन अब पाँच के बजाय छह तत्वों के साथ। हालाँकि, एक और तरीका है - एपेंड फ़ंक्शन का उपयोग करने का:
>संलग्न करें(उम्र,31)
25 20 9 44 37 31
ध्यान दें कि हम c() फ़ंक्शन को याद करके कई मान सम्मिलित कर सकते हैं:
> संलग्न करें(आयु,सी(31,33,35))
25 20 9 44 37 31 33 35
फ़ंक्शन आपको आफ्टर पैरामीटर का उपयोग करके वेक्टर में कहीं भी तत्व सम्मिलित करने की अनुमति देता है। डिफ़ॉल्ट बाद=लंबाई(x) है, जिसका अर्थ है कि तत्व अंत में जोड़े जाते हैं। लेकिन मान लीजिए कि हम दूसरे के बाद अपना छठा व्यक्ति सम्मिलित करना चाहते हैं:
> संलग्न करें (उम्र, 31, बाद=2)
25 20 31 9 44 37
सदिशों के साथ संचालन, या सदिशों के साथ क्या किया जा सकता है?
आप एक वेक्टर के सभी तत्वों के साथ एक साथ काम कर सकते हैं। इसलिए किसी वेक्टर में एक संख्या जोड़ना वेक्टर के प्रत्येक तत्व में इस संख्या को जोड़ने के बराबर है। या, उदाहरण के लिए, यह पता लगाने के लिए कि हमारे उदाहरण में प्रत्येक व्यक्ति कितने दशकों तक जीवित रहा, आप यह कर सकते हैं:
>उम्र/10
2.5 2.0 0.9 4.4 3.7
इसी प्रकार पैराग्राफ में वर्णित जोड़, घटाव और अन्य परिचालनों के साथ भी
सदिशों, सदिशों के तत्वों की तुलना कैसे करें?
मान लीजिए कि हमें यह पता लगाने की आवश्यकता है कि वेक्टर के कौन से तत्व (मान लें कि यह समान आयु है) एक निश्चित संख्या से अधिक हैं (उदाहरण के लिए, हमारे छोटे नमूने में से कौन सा वयस्क है)। प्रत्येक तत्व के लिए R बताएगा कि क्या स्थिति सत्य है, यानी TRUE (सही) या FALSE (गलत)। यह कुछ इस तरह दिखेगा:
>उम्र
25 20 31 9 44 37
>उम्र>=18
सत्य सत्य असत्य सत्य सत्य
लेकिन हो सकता है कि आप एक ही उत्तर पाना चाहें, उदाहरण के लिए, क्या यह सच है कि सभी तत्व एक शर्त को पूरा करते हैं? या क्या ऐसे कोई तत्व हैं जो स्थिति से बिल्कुल मेल खाते हैं? ऐसा करने के लिए, हम क्रमशः दो फ़ंक्शन, सभी() और कोई भी() का उपयोग करते हैं
all(x1,x2,...,xn) - प्रश्न का उत्तर देंगे, क्या यह सच है कि सभी स्थितियाँ (x1, x2, ... और xn) सत्य हैं? अर्थात् यह एक तार्किक संयोजन है। उदाहरण के लिए:
> सभी (आयु >= 7, आयु सत्य
#वास्तव में, सभी विषय सात से कम और साठ से कम उम्र के नहीं हैं
> सभी (उम्र >=18, 1 > 0)
असत्य
#हालाँकि, बेशक, एक शून्य से भी बड़ा है, हमारे विषयों में एक नौ साल का है, इसलिए यह सच नहीं है
कोई भी(x1,x2,...,xn) - इस प्रश्न का उत्तर देगा कि क्या शर्तों (x1, x2, ..., xn) में से कम से कम एक सत्य है? अर्थात् यह एक तार्किक वियोजन है। उदाहरण:
> कोई भी (उम्र >=18, 1 > 0)
सत्य
अंत में, आप दो वैक्टरों की एक दूसरे से तुलना कर सकते हैं। लेकिन इसके लिए या तो यह आवश्यक है कि बड़े वाले की लंबाई छोटे वाले की लंबाई की गुणज हो या लंबाई बराबर हो। उदाहरण:
> ए > ए > बी
असत्य असत्य असत्य सत्य सत्य
संख्याओं का क्रम कैसे निर्धारित करें?
- ऑपरेटर:
- seq(से,से,द्वारा,लंबाई,साथ) - से शुरू होकर, चरण दर चरण समाप्त होने वाला एक क्रम बनाता है। आप लंबाई पैरामीटर का उपयोग करके श्रृंखला की लंबाई निर्धारित कर सकते हैं या लंबाई को किसी अन्य वेक्टर के बराबर कर सकते हैं। तर्क: से, से, द्वारा, लंबाई, साथ (समान लंबाई...)
- प्रतिनिधि (ए, बार, प्रत्येक) - वेक्टर को बार-बार दोहराएं या हर बार प्रत्येक तत्व को दोहराएं। तर्क: वेक्टर, समय, प्रत्येक
छंटाई
- क्रमबद्ध करें (v,बढ़ते हुए) - वेक्टर v को क्रमबद्ध करें; वृद्धि - बूलियन, सत्य - आरोही, असत्य - अवरोही, आप इसके स्थान पर वृद्धि = घटती हुई लिख सकते हैं;
- आदेश देना()
आप स्क्रिप्ट को अतुल्यकालिक पृष्ठभूमि प्रक्रिया के रूप में चलाने के लिए system() और Rscript का उपयोग कर सकते हैं:
प्रणाली( "Rscript -e "source(\"your-script.R\")"", प्रतीक्षा करें = गलत ) ... save.image ("स्क्रिप्ट-आउटपुट.RData") बिल्ली ("स्क्रिप्ट पूर्ण\n\n")उम्मीद है ये मदद करेगा!
मैं आर कंसोल से पृष्ठभूमि में एक आर स्क्रिप्ट चलाना चाहता हूं।
कंसोल से, मैं आमतौर पर स्रोत के रूप में एक आर स्क्रिप्ट चलाता हूं ("~/.active-rstudio-document)। मुझे जारी रखने के लिए स्क्रिप्ट समाप्त होने तक इंतजार करना होगा। इसके बजाय, मैं चाहता हूं कि आर पृष्ठभूमि में चले जबकि मैं जारी रख सकूं कंसोल में काम करने के लिए। क्या मुझे किसी तरह से सूचित किया जाना चाहिए जब आर एक स्रोत कमांड को समाप्त करता है?
यह काफी मददगार हो सकता है क्योंकि हम अक्सर देखते हैं कि काम में काफी समय लग जाता है।
पुनश्च - मैं चाहता हूं कि मूल स्क्रिप्ट उसी मेमोरी स्पेस में चले, नई नहीं। इसलिए फोर्क, सिस्टम आदि जैसे समाधान मेरे लिए काम नहीं करेंगे। मैं देख रहा हूं कि क्या मैं एक आर स्क्रिप्ट को एक अलग प्रक्रिया के बजाय एक अलग थ्रेड के रूप में चला सकता हूं।
R स्क्रिप्ट के साथ काम करते समय, आपको इसे स्वचालित रूप से अपडेट करने की आवश्यकता हो सकती है। "टास्क शेड्यूलआर" पैकेज आपको विंडोज़ टास्क शेड्यूल में दैनिक, साप्ताहिक, हर एन मिनट में, विंडोज़ शुरू होने के बाद, आदि में आर स्क्रिप्ट चलाने के लिए शेड्यूल सेट करने में मदद करता है।
- पैकेज स्थापित करें "टास्क शेड्यूलआर" लाइब्रेरी (डेवटूल्स) इंस्टॉल.पैकेजेज ("डेवटूल्स") इंस्टॉल_जीथब ("जेविजेफेल्स/टास्क शेड्यूलआर") लाइब्रेरी (टास्क शेड्यूलआर)
हम "devtools" पैकेज का उपयोग करते हैं, जो आपको सीधे GitHub से पैकेज डाउनलोड और इंस्टॉल करने की अनुमति देता है।
- इसके बाद, स्क्रिप्ट के लॉन्च को कॉन्फ़िगर करने के लिए, आप या तो फॉर्म के माध्यम से इंटरैक्टिव कॉन्फ़िगरेशन का उपयोग कर सकते हैं, या कोड की कुछ पंक्तियाँ लिखकर।
ऐडिंस के माध्यम से टास्क शेड्यूलर में आर स्क्रिप्ट शेड्यूल सेट करना:
TaskscheduleR पैकेज के फ़ंक्शंस का उपयोग करके R स्क्रिप्ट शेड्यूल सेट करना:
पैकेज विशेषताएं:
- विंडोज़ टास्क शेड्यूलर में सभी कार्यों की सूची प्राप्त करें
- Windows टास्क शेड्यूलर से कोई कार्य हटाएँ
- आर स्क्रिप्ट लॉन्च कार्य जोड़ें
- निम्नलिखित शेड्यूल उपलब्ध हैं: 'एक बार', 'मासिक', 'साप्ताहिक', 'दैनिक', 'प्रति घंटा', 'मिनट', 'ऑनलॉगन', 'ऑनिडल'
हम किस पर ध्यान देते हैं:
- तारिख का प्रारूप. इसे आपके कंप्यूटर पर दिनांक प्रारूप से मेल खाना चाहिए। अन्यथा, हमें या तो स्क्रिप्ट लॉन्च शेड्यूल सेट करने में त्रुटि मिलेगी, या पूरी तरह से अलग तारीख मिलेगी।
- कंप्यूटर गतिविधि. स्क्रिप्ट चलने पर कंप्यूटर चालू होना चाहिए
- अन्य स्क्रिप्ट शेड्यूल की उपलब्धता. समान नाम से नया शेड्यूल सेट करते समय, पिछला शेड्यूल हटा दिया जाता है।
