R CMD BATCH को कमांड लाइन तर्क पास करना

Question

मैं R CMD BATCH my_script.Rएक Rस्क्रिप्ट को निष्पादित करने के लिए एक टर्मिनल से उपयोग कर रहा हूं । मैं अब उस बिंदु पर हूं जहां मैं कमांड को एक तर्क देना चाहता हूं, लेकिन कुछ मुद्दों पर काम कर रहा हूं। अगर मैं करता हूँ R CMD BATCH my_script.R blablaतो blablaआउटपुट फाइल बन जाती है, बजाय इसके कि आर स्क्रिप्ट के लिए उपलब्ध तर्क के रूप में व्याख्या की जा रही है।

मैंने कोशिश की है Rscript my_script.R blablaजो blablaएक तर्क के रूप में सही ढंग से पारित करने के लिए लगता है , लेकिन फिर मुझे my_script.Routआउटपुट फ़ाइल नहीं मिलती है जो मुझे मिलती है R CMD BATCH(मुझे .Routफ़ाइल चाहिए)। जब मैं Rscriptअपने चयन के फ़ाइल नाम के लिए एक कॉल के आउटपुट को पुनर्निर्देशित कर सकता हूं, तो मुझे उस तरह से फ़ाइल में शामिल आर इनपुट कमांड नहीं मिलेंगे जिस तरह R CMD BATCHसे .Routफ़ाइल में होती है।

इसलिए, आदर्श रूप से, मैं एक R CMD BATCHविधि के माध्यम से निष्पादित की जा रही आर स्क्रिप्ट के लिए तर्कों को पारित करने का एक तरीका हूं, हालांकि Rscriptअगर यह एक तुलनीय .Routफ़ाइल का उत्पादन करने का एक तरीका है, तो इसका उपयोग करके एक दृष्टिकोण से खुश होंगे ।

Answer 1

मेरी धारणा यह है कि R CMD BATCHथोड़ी राहत है। किसी भी स्थिति में, अधिक नवीनतम Rscriptनिष्पादन योग्य (सभी प्लेटफार्मों पर उपलब्ध), साथ में commandArgs()प्रोसेसिंग कमांड लाइन तर्कों को बहुत आसान बनाता है।

एक उदाहरण के रूप में, यहाँ एक छोटी स्क्रिप्ट है - इसे कॉल करें "myScript.R":

## myScript.R
args <- commandArgs(trailingOnly = TRUE)
rnorm(n=as.numeric(args[1]), mean=as.numeric(args[2]))

और यहाँ कमांड लाइन से इसे लागू करना कैसा दिखता है

> Rscript myScript.R 5 100
[1]  98.46435 100.04626  99.44937  98.52910 100.78853

---

संपादित करें:

ऐसा नहीं है कि मैं इसे की सलाह देते हैं, लेकिन ... के संयोजन का उपयोग source()और sink(), आप हो सकता है Rscriptएक का निर्माण करने के .Routद्वारा उत्पादित ऐसे ही फ़ाइल R CMD BATCH। एक तरीका यह होगा कि आप थोड़ी सी स्क्रिप्ट बनाएं - इसे कॉल करें RscriptEcho.R- जिसे आप सीधे रुपये के साथ कहते हैं। यह इस तरह लग सकता है:

## RscriptEcho.R
args <- commandArgs(TRUE)
srcFile <- args[1]
outFile <- paste0(make.names(date()), ".Rout")
args <- args[-1]

sink(outFile, split = TRUE)
source(srcFile, echo = TRUE)

अपनी वास्तविक स्क्रिप्ट निष्पादित करने के लिए, आप तब करेंगे:

Rscript RscriptEcho.R myScript.R 5 100
[1]  98.46435 100.04626  99.44937  98.52910 100.78853

जो myScript.Rआपूर्ति किए गए तर्कों के साथ निष्पादित करेगा और विशिष्ट नाम के इनपुट, आउटपुट और संदेशों को सिंक करेगा .Rout।

Edit2:
आप रुपये को मौखिक रूप से चला सकते हैं और क्रिया आउटपुट को एक फ़ाइल में रख सकते हैं।

Rscript --verbose myScript.R 5 100 > myScript.Rout

Comments

मुझे यह भी धारणा R CMD BATCHहै कि यह एक अवशेष है। हालाँकि मुझे इसके बारे में यह पसंद है कि यह एक ऐसी .Routफ़ाइल का उत्पादन करता है जिसमें न केवल स्क्रिप्ट आउटपुट शामिल होता है, बल्कि .Rउस आउटपुट को उत्पन्न करने वाली स्क्रिप्ट फ़ाइल से इनपुट कमांड / टिप्पणियों को भी इंटरलेय करता है ।

— ब्राइस थॉमस

मैं तुम्हें सुनता हूं। यह था (मुझे लगता है कि अभी भी है!) का एक अच्छा पहलू है R CMD BATCH।

— जोश ओ'ब्रायन

लेकिन मुझे लगता है कि आप से बेहतर कर सकते R CMD BATCHके साथ knitr, उदाहरण के लिए Rscript -e "knitr::stitch(commandArgs(TRUE)[1])" my_script.R(आप की जगह ले सकता stitchके साथ stitch_rhtmlया stitch_rmd, और आप स्थापित करने की आवश्यकता knitrसे Github के बाद से मैं सिर्फ में एक बग मिला stitch...)

— Yihui झी

बस मेरे 0.02 को जोड़ने के लिए, टर्मिनल से पुनर्निर्देशन का उपयोग करना भी आसान है। एक उदाहरण है Rscript myfile.R > path/to/mylog.Routऔर इसके बजाय stdout (स्क्रीन) पर मुद्रित होने के लिए, फ़ाइल का आउटपुट आपकी .Routफ़ाइल में सहेजा जाता है ।

— जेम्स प्रिंगल

@JamesPringle में जोड़ने के लिए, मैं अक्सर चाहता हूं कि मेरा आउटपुट स्क्रीन पर मुद्रित हो (वास्तविक समय में मॉनिटर करने के लिए) और एक फ़ाइल (बाद में देखने के लिए)। मुझे क्या करनाRscript myfile.R | tee mylog.Rout

— हाइजेनबर्ग

Answer 2

यहाँ वर्णित विकल्पों की कोशिश करने के बाद, मुझे आर-ब्लॉगर्स में फॉरेस्टर की यह पोस्ट मिली। मुझे लगता है कि यह एक साफ विकल्प है।

मैंने उसका कोड यहाँ रखा:

कमांड लाइन से

$ R CMD BATCH --no-save --no-restore '--args a=1 b=c(2,5,6)' test.R test.out &

Test.R

##First read in the arguments listed at the command line
args=(commandArgs(TRUE))

##args is now a list of character vectors
## First check to see if arguments are passed.
## Then cycle through each element of the list and evaluate the expressions.
if(length(args)==0){
    print("No arguments supplied.")
    ##supply default values
    a = 1
    b = c(1,1,1)
}else{
    for(i in 1:length(args)){
      eval(parse(text=args[[i]]))
    }
}

print(a*2)
print(b*3)

टेस्ट में

> print(a*2)
[1] 2
> print(b*3)
[1]  6 15 18

वनपाल को धन्यवाद !

Comments

नोट करने के लिए महत्वपूर्ण है, अगर तर्क प्रकार के चरित्र के हैं, तो एकल / दोहरे उद्धरण चिह्नों का उपयोग करने की आवश्यकता नहीं है। जैसे: R CMD BATCH '--args a = FolderName' test.Rout.out &

— d2a2d

जैसा कि फॉरेस्टर की पोस्ट में बताया गया --argsहै, कुंजी है। यह भी काम करता है R --no-save --no-restore --args a=1 < test.RऔरR --no-save --no-restore < test.R --args a=1

— डेव

क्या कमांड लाइन से --args में तर्क पारित करने का कोई तरीका है? तो कहते हैं कि हम कमांड लाइन में लूप के लिए करना चाहते हैं, और फिर इसे --args लाइन में भेजते हैं।

— user2809432

Answer 3

आपके आर स्क्रिप्ट में, कहा जाता है test.R:

args <- commandArgs(trailingOnly = F)
myargument <- args[length(args)]
myargument <- sub("-","",myargument)
print(myargument)
q(save="no")

कमांड लाइन रन से:

R CMD BATCH -4 test.R

आपकी आउटपुट फ़ाइल, test। आउट, यह दर्शाएगी कि तर्क 4को R को सफलतापूर्वक पास कर दिया गया है:

cat test.Rout

> args <- commandArgs(trailingOnly = F)
> myargument <- args[length(args)]
> myargument <- sub("-","",myargument)
> print(myargument)
[1] "4"
> q(save="no")
> proc.time()
user  system elapsed 
0.222   0.022   0.236 

Answer 4

आपको तर्कों को पहले रखने my_script.Rऔर -तर्कों पर उपयोग करने की आवश्यकता है, जैसे

R CMD BATCH -blabla my_script.R

commandArgs()-blablaइस मामले में एक चरित्र स्ट्रिंग के रूप में प्राप्त करेंगे। विवरण के लिए सहायता देखें:

$ R CMD BATCH --help
Usage: R CMD BATCH [options] infile [outfile]

Run R non-interactively with input from infile and place output (stdout
and stderr) to another file.  If not given, the name of the output file
is the one of the input file, with a possible '.R' extension stripped,
and '.Rout' appended.

Options:
  -h, --help        print short help message and exit
  -v, --version     print version info and exit
  --no-timing           do not report the timings
  --            end processing of options

Further arguments starting with a '-' are considered as options as long
as '--' was not encountered, and are passed on to the R process, which
by default is started with '--restore --save --no-readline'.
See also help('BATCH') inside R.

Comments

मैं अगर मैं इसे इस तरह से और स्क्रिप्ट उपयोग में क्या नोटिस args <- commandArgs(FALSE)और फिर आर्ग प्रिंट, मैं सभी तर्कों के साथ खत्म हो, उन जो मेरा है, जैसे नहीं हैं --restore, --saveआदि अगर मैं का उपयोग commandArgs(TRUE)मैं सब पर कोई बहस मिलता है। क्या केवल मेरे अपने अतिरिक्त तर्क प्राप्त करने का कोई तरीका है? --argsहोनहार लग रहा है, लेकिन मैं इसे काम करने के लिए सक्षम नहीं किया गया है ...

— ब्रायस थॉमस

आपको अंत से तर्क गिनना होगा (जैसे आकार -2, आकार -1, आकार) - आपका अंत हमेशा रहेगा।

— 20

Answer 5

मैं एक उत्तर जोड़ता हूं क्योंकि मुझे लगता है कि एक पंक्ति समाधान हमेशा अच्छा होता है! अपनी myRscript.Rफ़ाइल के ऊपर , निम्न पंक्ति जोड़ें:

eval(parse(text=paste(commandArgs(trailingOnly = TRUE), collapse=";")))

फिर अपनी स्क्रिप्ट को कुछ इस तरह से सबमिट करें:

R CMD BATCH [options] '--args arguments you want to supply' myRscript.R &

उदाहरण के लिए:

R CMD BATCH --vanilla '--args N=1 l=list(a=2, b="test") name="aname"' myscript.R &

फिर:

> ls()
[1] "N"    "l"    "name"

Answer 6

यहाँ कमांड लाइन आर्ग्स को प्रोसेस करने का एक और तरीका है R CMD BATCH। मेरा दृष्टिकोण, जो यहां पहले के उत्तर पर बनाता है , आपको कमांड लाइन पर तर्क निर्दिष्ट करने की अनुमति देता है और, आपकी आर स्क्रिप्ट में, उनमें से कुछ या सभी डिफ़ॉल्ट मान देते हैं।

यहाँ एक आर फ़ाइल है, जो मैं नाम है test.R :

defaults <- list(a=1, b=c(1,1,1)) ## default values of any arguments we might pass

## parse each command arg, loading it into global environment
for (arg in commandArgs(TRUE))
  eval(parse(text=arg))

## if any variable named in defaults doesn't exist, then create it
## with value from defaults
for (nm in names(defaults))
  assign(nm, mget(nm, ifnotfound=list(defaults[[nm]]))[[1]])

print(a)
print(b)

यदि मैं टाइप करता हूं, तो कमांड लाइन पर

R CMD BATCH --no-save --no-restore '--args a=2 b=c(2,5,6)' test.R

R के भीतर तो हमारे पास a= 2और b= होगा c(2,5,6)। लेकिन मैं कह सकता हूँ, छोड़ो b, और एक और तर्क में जोड़ें c:

R CMD BATCH --no-save --no-restore '--args a=2 c="hello"' test.R

फिर R में हमारे पास a= 2, b= c(1,1,1)(डिफ़ॉल्ट), और c= होगा "hello"।

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

## defaults should be either NULL or a named list
parseCommandArgs <- function(defaults=NULL, envir=globalenv()) {
  for (arg in commandArgs(TRUE))
    eval(parse(text=arg), envir=envir)

  for (nm in names(defaults))
    assign(nm, mget(nm, ifnotfound=list(defaults[[nm]]), envir=envir)[[1]], pos=envir)
}

## example usage:
parseCommandArgs(list(a=1, b=c(1,1,1)))