r - आरएमडी दस्तावेज़ बुनाई करते समय एक प्रारंभिक निकास का अनुरोध कैसे करें?




markdown knitr (2)

मान लीजिए कि आपके पास एक आर मार्कडाउन दस्तावेज है जो सफाई से प्रस्तुत नहीं करेगा।

मुझे पता है कि आप TRUE को knitr chunk विकल्प error सेट कर सकते हैं ताकि यह अनुरोध किया जा सके कि मूल्यांकन जारी रहे, यहां तक ​​कि त्रुटियों की उपस्थिति में भी। आप इसे error = TRUE माध्यम से या अधिक वैश्विक तरीके से knitr::opts_chunk$set(error = TRUE) माध्यम से एक व्यक्ति के लिए कर सकते हैं।

लेकिन कभी-कभी ऐसी त्रुटियां होती हैं जो अभी भी बुनाई प्रक्रिया के लिए घातक हैं। दो उदाहरण जो मैंने हाल ही में सामने आए हैं: वर्तमान वर्किंग डायरेक्टरी (उफ़!) को unlink() करने की कोशिश कर रहा है और rstudioapi::getVersion() इनलाइन R कोड से RStudio उपलब्ध नहीं होने पर कॉल कर रहा है। क्या इस प्रकार की त्रुटियों का सामान्य विवरण है, अर्थात error = TRUE की पहुंच से परे error = TRUE ? क्या इनलाइन आर कोड बनाम विखंडू में त्रुटियों को सहन करने का एक तरीका है?

इसके अलावा, क्या इस स्थिति में जल्दी से बुनाई शुरू करने या डिबगिंग को स्वचालित करने के लिए और अधिक आधिकारिक तरीके हैं?


IMHO, एक Rmd दस्तावेज़ को डिबग करने में कठिनाई एक चेतावनी है कि कुछ गलत है। मेरे पास अंगूठे का एक नियम है: Rmd के बाहर भारी लिफ्टिंग करें। Rmd के अंदर रेंडरिंग करें, और केवल रेंडरिंग करें। जो Rmd कोड को सरल रखता है।

मेरे बड़े आर कार्यक्रम इस तरह दिखते हैं।

data <- loadData()
analytics <- doAnalytics(data)
rmarkdown::render("theDoc.Rmd", envir=analytics)

(यहां, doAnalytics एक सूची या वातावरण लौटाता है। वह सूची या वातावरण एनवीआर पैरामीटर के माध्यम से Rmd दस्तावेज़ को दिया जाता है, जो दस्तावेज़ के अंदर उपलब्ध एनालिटिक्स संगणनाओं के परिणामों को उपलब्ध कराता है।)

DoAnalytics फ़ंक्शन जटिल गणना करता है। मैं नियमित टूल का उपयोग करके इसे डीबग कर सकता हूं, और मैं आसानी से इसके आउटपुट की जांच कर सकता हूं। जब तक मैं रेकॉर्डडाउन :: रेंडर कहता हूं, मुझे पता है कि हार्ड सामान सही तरीके से काम कर रहा है। आरएमडी कोड सिर्फ "यह प्रिंट करें" और "प्रारूप है कि", डीबग करना आसान है।

जिम्मेदारी के इस विभाजन ने मुझे अच्छी तरह से सेवा दी है, और मैं इसकी सिफारिश कर सकता हूं। विशेष रूप से एक गतिशील रूप से प्रस्तुत दस्तावेज़ के अंदर दफन जटिल गणना डिबगिंग के मन-झुकने कार्य की तुलना में।


बुनाई की प्रक्रिया से जल्दी बाहर निकलने के लिए, आप स्रोत डॉक्यूमेंट में (कोड knitr::knit_exit() या इनलाइन अभिव्यक्ति में knitr::knit_exit() कहीं भी knitr::knit_exit() उपयोग कर सकते हैं। एक बार जब knit_exit() कहा जाता है, तो knitr बाकी सभी दस्तावेज़ों को अनदेखा कर देगा और अब तक एकत्र किए गए परिणामों को लिख देगा।

फिलहाल इनलाइन आर कोड में त्रुटियों को सहन करने का कोई तरीका नहीं है। आपको यह सुनिश्चित करने की आवश्यकता है कि इनलाइन आर कोड हमेशा त्रुटियों 1 के बिना चलता है। यदि त्रुटियां होती हैं, तो आपको लाइनों की वह सीमा देखनी चाहिए , जो कंसोल में निट्र लॉग से त्रुटि उत्पन्न करती है, Quitting from lines x1-x2 (filename.Rmd)आरएमडी Quitting from lines x1-x2 (filename.Rmd) वाले फॉर्म के। फिर आप फ़ाइल फ़ाइल filename.Rmd जा सकते हैं। filename.Rmd और देखें कि x1 से x2 तक की लाइनों में क्या गलत है। समान चीज़ कोड विकल्प के साथ कोड विकल्प पर लागू होती है error = FALSE

उपरोक्त उल्लिखित त्रुटियों के अलावा, समस्या के स्रोत को खोजने के लिए यह मुश्किल हो सकता है। उदाहरण के लिए, जब आप अनजाने में वर्तमान निर्देशिका को unlink() कर देते हैं, तो इसे बुनाई की प्रक्रिया को रोकना नहीं चाहिए, क्योंकि unlink() वैसे भी सफल हुआ। आप बुनाई की प्रक्रिया के बाद समस्याओं में भाग सकते हैं, उदाहरण के लिए, LaTeX / HTML आउटपुट आंकड़ा फ़ाइलें नहीं पा सकते हैं। इस मामले में, आप एक-एक करके दस्तावेज़ में सभी कोड विखंडू पर knit_exit() लागू करने का प्रयास कर सकते हैं। इसे प्राप्त करने का एक तरीका एक निश्चित चंक के बाद knit_exit() चलाने के लिए एक चंक हुक स्थापित करना है। नीचे रैखिक खोज का उपयोग करने का एक उदाहरण है (आप इसके बजाय बिसनेस का उपयोग करके इसे सुधार सकते हैं):

#' Render an input document chunk by chunk until an error occurs
#' 
#' @param input the input filename (an Rmd file in this example)
#' @param compile a function to compile the input file, e.g. knitr::knit, or
#'   rmarkdown::render
knit_debug = function(input, compile = knitr::knit) {
  library(knitr)
  lines = readLines(input)
  chunk = grep(all_patterns$md$chunk.begin, lines)  # line number of chunk headers

  knit_hooks$set(debug = function(before) {
    if (!before) {
      chunk_current <<- chunk_current + 1
      if (chunk_current >= chunk_num) knit_exit()
    }
  })

  opts_chunk$set(debug = TRUE)

  # try to exit after the i-th chunk and see which chunk introduced the error
  for (chunk_num in seq_along(chunk)) {
    chunk_current = 0  # a chunk counter, incremented after each chunk
    res = try(compile(input))
    if (inherits(res, 'try-error')) {
      message('The first error came from line ', chunk[chunk_num])
      break
    }
  }
}
  1. यह डिजाइन द्वारा है। मुझे लगता है कि कोड चंक्स के लिए error = TRUE होना एक अच्छा विचार है, क्योंकि कभी-कभी हम त्रुटियों को दिखाना चाहते हैं, उदाहरण के लिए, शिक्षण उद्देश्यों के लिए। हालाँकि, अगर मैं इनलाइन कोड के लिए त्रुटियों की अनुमति देता हूं, तो लेखक इनलाइन कोड में घातक त्रुटियों को पहचानने में विफल हो सकते हैं। इनलाइन कोड का उपयोग आम तौर पर इनलाइन मानों को एम्बेड करने के लिए किया जाता है, और मुझे नहीं लगता कि अगर इनलाइन मान एक त्रुटि है तो यह बहुत मायने रखता है। एक रिपोर्ट में एक वाक्य की कल्पना करें जैसे The P-value of my test is ERROR , और यदि निटर ने त्रुटि का संकेत नहीं दिया, तो इस मुद्दे को जानने के लिए लेखकों को रिपोर्ट आउटपुट को बहुत ध्यान से पढ़ना होगा। मुझे लगता है कि इस तरह की गलतियों को खोजने के लिए मानव आंखों पर निर्भर रहना एक बुरा विचार है।






knitr