दिलचस्प पोस्ट
Ggplot2 के साथ साइड-बाय-साइड प्लॉट्स कौन सा तेज है: एकाधिक एकल INSERT या एक बहु-पंक्ति INSERT? UIImage से Exif डेटा प्राप्त करें – UIImagePickerController दिए गए URL को एप्लिकेशन कॉन्फ़िगरेशन द्वारा अनुमत नहीं है स्टैक ऑवरफ्लो ऑटो-लिंक व्यवहार की नकल कैसे करें मैं ईमेल में HTML प्रपत्र कैसे भेजूं .. सिर्फ मेलो नहीं बेसिक प्रमाणीकरण का उपयोग करके उपयोगकर्ता को वेब साइट से लॉग आउट कैसे करें? किसी प्रदाता में केवल कुछ विशिष्ट ETW कार्य के लिए स्टैक सक्रिय करें? ActiveRecord Query Union सीएसएस में मार्जिन बनाम पैडिंग का इस्तेमाल कब करना मैं प्रोग्राम को कई लाइनों में लेआउट में एक-एक करके बटन कैसे जोड़ूं? ऑब्जेक्ट प्रॉपर्टी को दूसरे ऑब्जेक्ट में डुप्लिकेट कैसे करें? कैसे पुनरावण इतिहास निर्यात करने के लिए मर्क्यूरीयल या जीआईटी से सीवीएस? HashSet <T> और सूची <टी> के बीच अंतर क्या है? "चेतावनी सामग्री शरीर की लंबाई की लंबाई निर्धारित नहीं कर सका" क्या मतलब है और इसे कैसे से छुटकारा मिल सकता है?

कैसे एक महान आर प्रतिलिपि प्रस्तुत करने योग्य उदाहरण बनाने के लिए?

सहकर्मियों के साथ प्रदर्शन, शिक्षण, मेलिंग सूचियों पर मार्गदर्शन के लिए एक बग रिपोर्ट भेजने या खोजना और यहां पर SO पर, एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण अक्सर पूछे जाने और हमेशा उपयोगी होते हैं।

एक उत्कृष्ट उदाहरण बनाने के लिए आपके सुझाव क्या हैं? आप डेटा स्ट्रक्चर्स को टेक्स्ट प्रारूप में आर से कैसे पेस्ट करते हैं? आपको अन्य क्या जानकारी शामिल करनी चाहिए?

क्या dput() , dump() या structure() का उपयोग करने के अलावा अन्य युक्तियां हैं? आपको library() कब शामिल करना चाहिए library() या require() बयान की require() ? c , df , data इत्यादि के अलावा, कौन से आरक्षित शब्द को बचाना चाहिए?

कैसे एक महान आर प्रतिलिपि प्रस्तुत करता है उदाहरण?

वेब के समाधान से एकत्रित समाधान "कैसे एक महान आर प्रतिलिपि प्रस्तुत करने योग्य उदाहरण बनाने के लिए?"

एक न्यूनतम प्रतिलिपि प्रस्तुतकर्ता उदाहरण में निम्नलिखित आइटम शामिल हैं:

  • एक न्यूनतम डाटासेट, त्रुटि को पुन: उत्पन्न करने के लिए आवश्यक है
  • त्रुटि को पुन: उत्पन्न करने के लिए न्यूनतम रननेबल कोड आवश्यक है, जो दी गई डेटासेट पर चलाया जा सकता है।
  • उपयोग किए गए संकुल, आर संस्करण, और सिस्टम पर आवश्यक जानकारी चलाना है।
  • यादृच्छिक प्रक्रियाओं के मामले में, एक बीज ( set.seed() द्वारा सेट किया set.seed() ) पुनरुत्पादन के लिए

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

एक न्यूनतम डेटासेट का निर्माण

अधिकांश मामलों में, यह केवल कुछ वैल्यू के साथ एक वेक्टर / डेटा फ्रेम प्रदान करके आसानी से किया जा सकता है। या आप अंतर्निहित डेटासेट में से एक का उपयोग कर सकते हैं, जो कि अधिकांश पैकेजों के साथ प्रदान किए गए हैं।
अंतर्निहित डेटासेट की एक विस्तृत सूची को library(help = "datasets") साथ देखा जा सकता है। प्रत्येक डाटासेट का एक संक्षिप्त विवरण है और अधिक जानकारी उदाहरण के लिए ?mtcars साथ प्राप्त की जा सकती है जहां सूची में 'mtcars' डेटासेट में से एक है। अन्य पैकेज में अतिरिक्त डेटासेट हो सकते हैं।

एक वेक्टर बनाना आसान है। कभी-कभी इसमें कुछ यादृच्छिकता जोड़ना आवश्यक होता है, और ऐसा करने के लिए इसमें बहुत सारे कार्य हैं sample() एक वेक्टर को यादृच्छिक कर सकते हैं, या केवल कुछ मानों के साथ एक यादृच्छिक वेक्टर दे सकते हैं। letters वर्णमाला युक्त एक उपयोगी वेक्टर है। इसका कारक बनाने के लिए इस्तेमाल किया जा सकता है

कुछ उदाहरण:

  • यादृच्छिक मूल्य: x <- rnorm(10) सामान्य वितरण के लिए, x <- runif(10) समान वितरण के लिए, …
  • कुछ मानों का क्रमचय: x <- sample(1:10) सदिश 1:10 के लिए यादृच्छिक क्रम में।
  • एक यादृच्छिक कारक: x <- sample(letters[1:4], 20, replace = TRUE)

मैट्रिक्स के लिए, matrix() उपयोग कर सकते हैं, जैसे:

 matrix(1:10, ncol = 2) 

डाटा फ़्रेम बनाना डेटा. data.frame() का उपयोग करके किया जा सकता है। किसी को डेटा फ्रेम में प्रविष्टियों के नाम पर ध्यान देना चाहिए, और इसे अत्यधिक जटिल बनाने के लिए नहीं करना चाहिए

एक उदाहरण :

 Data <- data.frame( X = sample(1:10), Y = sample(c("yes", "no"), 10, replace = TRUE) ) 

कुछ प्रश्नों के लिए, विशिष्ट प्रारूपों की आवश्यकता हो सकती है इनके लिए, किसी भी प्रदान किए गए किसी भी प्रकार के किसी भी प्रकार का उपयोग कर सकते हैं: as.factor , as.Date , as.xts , … वेक्टर और / या डेटा फ़्रेम ट्रिक्स के साथ संयोजन में

अपना डेटा कॉपी करें

यदि आपके पास कुछ डेटा है जो इन सुझावों का उपयोग करने के लिए बहुत मुश्किल होगा, तो आप हमेशा अपने मूल डेटा का एक सबसेट बना सकते हैं जैसे, head() , subset() या सूचकांक फिर उदाहरण का उपयोग करें। dput() हमें ऐसा कुछ देने के लिए जो तुरंत आर में डाल सकते हैं:

 > dput(head(iris,4)) structure(list(Sepal.Length = c(5.1, 4.9, 4.7, 4.6), Sepal.Width = c(3.5, 3, 3.2, 3.1), Petal.Length = c(1.4, 1.4, 1.3, 1.5), Petal.Width = c(0.2, 0.2, 0.2, 0.2), Species = structure(c(1L, 1L, 1L, 1L), .Label = c("setosa", "versicolor", "virginica"), class = "factor")), .Names = c("Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width", "Species"), row.names = c(NA, 4L), class = "data.frame") 

अगर आपके डेटा फ्रेम के कई स्तरों के साथ एक कारक है, तो dput आउटपुट बोझल हो सकता है क्योंकि यह अभी भी सभी संभव कारक स्तरों को सूचीबद्ध करेगा भले ही वे आपके डेटा के सबसेट में मौजूद न हों। इस समस्या को हल करने के लिए, आप droplevels() फ़ंक्शन का उपयोग कर सकते हैं। सूचना नीचे प्रजातियों कैसे एक कारक है केवल एक स्तर के साथ:

 > dput(droplevels(head(iris, 4))) structure(list(Sepal.Length = c(5.1, 4.9, 4.7, 4.6), Sepal.Width = c(3.5, 3, 3.2, 3.1), Petal.Length = c(1.4, 1.4, 1.3, 1.5), Petal.Width = c(0.2, 0.2, 0.2, 0.2), Species = structure(c(1L, 1L, 1L, 1L), .Label = "setosa", class = "factor")), .Names = c("Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width", "Species"), row.names = c(NA, 4L), class = "data.frame") 

dput लिए एक अन्य चेतावनी यह है कि यह कुंजी वाले data.table लिए काम नहीं data.table ऑब्जेक्ट्स या समूह के लिए tbl_df (class grouped_df ) dplyr से इन मामलों में आप साझा करने से पहले एक नियमित डेटा फ़्रेम में परिवर्तित कर सकते हैं, dput(as.data.frame(my_data))

सबसे खराब परिदृश्य, आप पाठ प्रस्तुति दे सकते हैं जो read.table के text पैरामीटर का उपयोग करते हुए पढ़ा जा सकता है:

 zz <- "Sepal.Length Sepal.Width Petal.Length Petal.Width Species 1 5.1 3.5 1.4 0.2 setosa 2 4.9 3.0 1.4 0.2 setosa 3 4.7 3.2 1.3 0.2 setosa 4 4.6 3.1 1.5 0.2 setosa 5 5.0 3.6 1.4 0.2 setosa 6 5.4 3.9 1.7 0.4 setosa" Data <- read.table(text=zz, header = TRUE) 

न्यूनतम कोड का निर्माण

यह आसान हिस्सा होना चाहिए, लेकिन अक्सर नहीं है। आपको क्या नहीं करना चाहिए, यह है:

  • सभी प्रकार के डेटा रूपांतरण जोड़ें। सुनिश्चित करें कि उपलब्ध कराए गए आंकड़े पहले से ही सही प्रारूप में हैं (जब तक कि यह निश्चित रूप से समस्या नहीं है)
  • एक संपूर्ण फ़ंक्शन / कोड का टुकड़ा कॉपी करें जो त्रुटि प्रदान करता है सबसे पहले, त्रुटि की वजह से लाइनों का पता लगाने का प्रयास करें। अधिक बार नहीं, आपको यह पता चल जाएगा कि समस्या क्या है?

आपको क्या करना चाहिए, यह है:

  • जोड़ अगर आप किसी भी उपयोग करते हैं, तो कौन सा संकुल का उपयोग किया जाना चाहिए
  • यदि आप कनेक्शन या मैसेफ़ाइल खोलते हैं, तो उन्हें बंद करने के लिए कुछ कोड जोड़ें या फ़ाइलें हटाएं ( unlink() का उपयोग करके)
  • अगर आप विकल्पों को बदलते हैं, तो सुनिश्चित करें कि कोड में उन्हें वापस लौटने के लिए एक बयान दिया गया है। (जैसे op <- par(mfrow=c(1,2)) ...some code... par(op) )
  • परीक्षण कोड चलाने योग्य है यह सुनिश्चित करने के लिए एक नया, खाली आर सत्र में अपना कोड चलाएं। लोगों को कंसोल में अपने डेटा और अपना कोड कॉपी-पेस्ट कर पाएंगे और आपके पास जितनी हो सके उतनी ही मिलेगी।

अतिरिक्त जानकारी दें

ज्यादातर मामलों में, केवल आर संस्करण और ऑपरेटिंग सिस्टम पर्याप्त होगा। जब विरोध संकुल के साथ उठता है, तो sessionInfo() का उत्पादन वास्तव में मदद कर सकता है। अन्य अनुप्रयोगों (ओडीबीसी या अन्य सभी के माध्यम से) के संबंधों के बारे में बात करते समय, उन्हें उन लोगों के लिए संस्करण संख्या भी प्रदान करनी चाहिए, और यदि संभव हो तो सेटअप पर आवश्यक जानकारी भी।

यदि आप आर स्टूडियो में rstudioapi::versionInfo() का उपयोग कर रहे हैं तो अपने RStudio संस्करण की रिपोर्ट करने में सहायक हो सकते हैं।

अगर आपको विशिष्ट पैकेज के साथ कोई समस्या है तो आप पैकेज के संस्करण packageVersion("name of the package") देकर पैकेज के संस्करण को प्रदान करना चाह सकते हैं।

( http://adv-r.had.co.nz/Reproducibility.html से मेरी सलाह है। मैंने इसे कम लेकिन मीठा बनाने की कोशिश की है)

कैसे एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण लिखने के लिए

यदि आप एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण प्रदान करते हैं तो आपको आपकी आर समस्या के साथ अच्छी मदद मिल सकती है एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण किसी को अपनी समस्या को पुन: प्रतिलिपि बनाने और चिपकाने के लिए अनुमति देता है।

आपके उदाहरण प्रतिलिपि प्रस्तुत करने योग्य बनाने के लिए चार चीजें हैं जिनकी आपको आवश्यकता है: आवश्यक पैकेज, डेटा, कोड और आपके आर वातावरण का विवरण।

  • संकुल को स्क्रिप्ट के शीर्ष पर लोड किया जाना चाहिए, इसलिए यह देखना आसान है कि कौन सा उदाहरण की जरूरत है

  • किसी ईमेल या स्टैक अतिप्रवाह प्रश्न में डेटा को शामिल करने का सबसे आसान तरीका dput() का उपयोग करने के लिए आर कोड को पुन: उत्पन्न करने के लिए है उदाहरण के लिए, आर में mtcars डेटासेट को पुनः बनाने के लिए, मैं निम्नलिखित चरणों का पालन करता हूं:

    1. आर में dput(mtcars) चलाएं
    2. उत्पादन की प्रतिलिपि बनाएँ
    3. मेरी प्रतिलिपि प्रस्तुत करने योग्य स्क्रिप्ट में टाइप करें mtcars <- फिर पेस्ट करें
  • थोड़ा सा समय बिताना सुनिश्चित करें कि आपका कोड दूसरों के पढ़ने के लिए आसान है:

    • सुनिश्चित करें कि आपने रिक्त स्थान का उपयोग किया है और आपके चर नाम संक्षिप्त हैं, लेकिन जानकारीपूर्ण हैं

    • यह संकेत देने के लिए टिप्पणियों का उपयोग करें कि आपकी समस्या क्या है

    • समस्या से संबंधित नहीं है जो सब कुछ को हटाने के लिए अपनी पूरी कोशिश करो
      आपका कोड छोटा है, यह समझना आसान है।

  • अपने कोड में एक टिप्पणी में sessionInfo() का उत्पादन शामिल करें। यह आपके आर वातावरण को सारांशित करता है और यह जांचना आसान बनाता है कि क्या आप आउट-ऑफ-डेट पैकेज का उपयोग कर रहे हैं।

आप यह देख सकते हैं कि आपने वास्तव में एक ताजा आर सत्र शुरू करके और अपनी स्क्रिप्ट को चिपकाने के द्वारा प्रतिलिपि प्रस्तुत करने योग्य उदाहरण बनाया है।

अपने सभी कोड को एक ईमेल में डालने से पहले इसे http://gist.github.com/ पर डालें । यह आपके कोड को अच्छा सिंटैक्स हाइलाइटिंग देगा, और आपको ईमेल सिस्टम द्वारा गड़बड़ी करने के बारे में चिंता करने की ज़रूरत नहीं है।

निजी तौर पर, मैं "एक" लाइनर्स पसंद करता हूं लाइनों के साथ कुछ:

 my.df <- data.frame(col1 = sample(c(1,2), 10, replace = TRUE), col2 = as.factor(sample(10)), col3 = letters[1:10], col4 = sample(c(TRUE, FALSE), 10, replace = TRUE)) my.list <- list(list1 = my.df, list2 = my.df[3], list3 = letters) 

डेटा संरचना को लेखक की समस्या के विचार की नकल चाहिए और सही शब्दशः संरचना नहीं। मैं वाकई इसकी सराहना करता हूं जब चर मेरे खुद के चर या देवता को परहेज़ नहीं करते, फ़ंक्शन (जैसे df )

वैकल्पिक रूप से, कोई कुछ कोनों को कट सकता है और पहले से मौजूद डेटा सेट को इंगित करता है, जैसे कुछ:

 library(vegan) data(varespec) ord <- metaMDS(varespec) 

जिन विशेष पैकेजों का आप उपयोग कर रहे हैं, उनका उल्लेख करने के लिए मत भूलें।

यदि आप बड़ी वस्तुओं पर कुछ प्रदर्शित करने का प्रयास कर रहे हैं, तो आप कोशिश कर सकते हैं

 my.df2 <- data.frame(a = sample(10e6), b = sample(letters, 10e6, replace = TRUE)) 

यदि आप raster पैकेज के माध्यम से स्थानिक डेटा के साथ काम कर रहे हैं, तो आप कुछ यादृच्छिक डेटा उत्पन्न कर सकते हैं। पैकेज उदाहरण में बहुत सारे उदाहरण पाये जा सकते हैं, लेकिन यहां एक छोटा सा सोने का डला है।

 library(raster) r1 <- r2 <- r3 <- raster(nrow=10, ncol=10) values(r1) <- runif(ncell(r1)) values(r2) <- runif(ncell(r2)) values(r3) <- runif(ncell(r3)) s <- stack(r1, r2, r3) 

यदि आपको कुछ स्थानिक ऑब्जेक्ट की ज़रूरत है जो sp में लागू की गई है, तो आप "डेटा" पैकेज में बाह्य फाइलों (जैसे ईएसआरआई आकारफाइल) के माध्यम से कुछ डाटासेट प्राप्त कर सकते हैं (कार्य दृश्यों में स्थानिक दृश्य देखें)।

 library(rgdal) ogrDrivers() dsn <- system.file("vectors", package = "rgdal")[1] ogrListLayers(dsn) ogrInfo(dsn=dsn, layer="cities") cities <- readOGR(dsn=dsn, layer="cities") 

इस पोस्ट से प्रेरित होकर, अब मैं एक आसान समारोह का उपयोग कर रहा हूं
जब मुझे reproduce(<mydata>) पर पोस्ट करना पड़ता है reproduce(<mydata>)


त्वरित निर्देश

यदि पुन: उत्पन्न करने के लिए myData आपके ऑब्जेक्ट का नाम है, तो निम्न में आर चलाएं:

 install.packages("devtools") library(devtools) source_url("https://raw.github.com/rsaporta/pubR/gitbranch/reproduce.R") reproduce(myData) 

विवरण:

यह फ़ंक्शन dput लिए एक बुद्धिमान आवरण है और निम्नलिखित करता है:

  • स्वचालित रूप से एक बड़ा डेटा सेट नमूने (आकार और वर्ग के आधार पर। नमूना आकार समायोजित किया जा सकता है)
  • एक dput आउटपुट बनाता है
  • आपको निर्दिष्ट करने के लिए कि कौन सा कॉलम निर्यात करना है
  • इसके सामने सामने आ जाता है objName <- ... ताकि इसे आसानी से कॉपी किया जा सके + चिपकाया जा सके, लेकिन …
  • अगर मैक पर काम करना है, तो आउटपुट स्वचालित रूप से क्लिपबोर्ड पर कॉपी किया जाता है, ताकि आप इसे आसानी से चला सकें और फिर अपने प्रश्न को पेस्ट कर सकें।

स्रोत यहां उपलब्ध है:


उदाहरण:

 # sample data DF <- data.frame(id=rep(LETTERS, each=4)[1:100], replicate(100, sample(1001, 100)), Class=sample(c("Yes", "No"), 100, TRUE)) 

डीएफ लगभग 100 x 102 है। मैं 10 पंक्तियों और कुछ विशिष्ट स्तंभों का नमूना देना चाहता हूं

 reproduce(DF, cols=c("id", "X1", "X73", "Class")) # I could also specify the column number. 

निम्नलिखित आउटपुट देता है:

 This is what the sample looks like: id X1 X73 Class 1 A 266 960 Yes 2 A 373 315 No Notice the selection split 3 A 573 208 No (which can be turned off) 4 A 907 850 Yes 5 B 202 46 Yes 6 B 895 969 Yes <~~~ 70 % of selection is from the top rows 7 B 940 928 No 98 Y 371 171 Yes 99 Y 733 364 Yes <~~~ 30 % of selection is from the bottom rows. 100 Y 546 641 No ==X==============================================================X== Copy+Paste this part. (If on a Mac, it is already copied!) ==X==============================================================X== DF <- structure(list(id = structure(c(1L, 1L, 1L, 1L, 2L, 2L, 2L, 25L, 25L, 25L), .Label = c("A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y"), class = "factor"), X1 = c(266L, 373L, 573L, 907L, 202L, 895L, 940L, 371L, 733L, 546L), X73 = c(960L, 315L, 208L, 850L, 46L, 969L, 928L, 171L, 364L, 641L), Class = structure(c(2L, 1L, 1L, 2L, 2L, 2L, 1L, 2L, 2L, 1L), .Label = c("No", "Yes"), class = "factor")), .Names = c("id", "X1", "X73", "Class"), class = "data.frame", row.names = c(1L, 2L, 3L, 4L, 5L, 6L, 7L, 98L, 99L, 100L)) ==X==============================================================X== 

यह भी सूचना है कि पूरी तरह से आउटपुट एक अच्छी एकल, लंबी रेखा में है, कटा हुआ लाइनों का लंबा पैराग्राफ नहीं है। इसने SO प्रश्न पदों पर पढ़ने में आसान और पेस्ट को कॉपी करने में आसान बनाता है


अपडेट अक्टूबर 2013:

अब आप निर्दिष्ट कर सकते हैं कि पाठ आउटपुट की कितनी लाइनें उठेंगी (यानी, आप स्टैक ऑवरफ्लो में क्या पेस्ट करेंगे)। इस के लिए lines.out=n तर्क का प्रयोग करें। उदाहरण:

reproduce(DF, cols=c(1:3, 17, 23), lines.out=7) उपज:

  ==X==============================================================X== Copy+Paste this part. (If on a Mac, it is already copied!) ==X==============================================================X== DF <- structure(list(id = structure(c(1L, 1L, 1L, 1L, 2L, 2L, 2L, 25L,25L, 25L), .Label = c("A", "B", "C", "D", "E", "F", "G", "H","I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U","V", "W", "X", "Y"), class = "factor"), X1 = c(809L, 81L, 862L,747L, 224L, 721L, 310L, 53L, 853L, 642L), X2 = c(926L, 409L,825L, 702L, 803L, 63L, 319L, 941L, 598L, 830L), X16 = c(447L,164L, 8L, 775L, 471L, 196L, 30L, 420L, 47L, 327L), X22 = c(335L,164L, 503L, 407L, 662L, 139L, 111L, 721L, 340L, 178L)), .Names = c("id","X1", "X2", "X16", "X22"), class = "data.frame", row.names = c(1L,2L, 3L, 4L, 5L, 6L, 7L, 98L, 99L, 100L)) ==X==============================================================X== 

यहां एक अच्छी मार्गदर्शिका है:

http://www.r-bloggers.com/three-tips-for-posting-good-questions-to-r-help-and-stack-overflow/

लेकिन सबसे महत्वपूर्ण बात यह है: बस यह सुनिश्चित करें कि आप एक छोटा सा कोड बनाते हैं जो हम यह देख सकते हैं कि समस्या क्या है। इसके लिए एक उपयोगी कार्य है dput() , लेकिन अगर आपके पास बहुत बड़ा डेटा है तो आप एक छोटा सा नमूना डाटासेट बनाना चाहते हैं या केवल पहले 10 लाइनों का उपयोग कर सकते हैं

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

यह भी सुनिश्चित करें कि आपने पहचान ली है कि समस्या खुद कहां है उदाहरण "200 पर एक त्रुटि है" के साथ एक पूरी आर स्क्रिप्ट नहीं होना चाहिए। यदि आप डी में डीबगिंग टूल का उपयोग करते हैं (मैं browser() पसंद करता हूं) और Google आपको वास्तव में यह पहचानने में सक्षम होना चाहिए कि समस्या कहां है और एक तुच्छ उदाहरण को पुन: उत्पन्न करने में सक्षम होना चाहिए जिसमें एक ही चीज़ गलत हो

आर-हेल्प मेलिंग लिस्ट में एक पोस्टिंग गाइड है जिसमें जनसांख्यिकीय डेटा के एक उदाहरण सहित पूछने और जवाब देने वाले दोनों प्रश्न शामिल हैं:

उदाहरण: कभी-कभी यह एक छोटा उदाहरण प्रदान करने में सहायता करता है कि कोई वास्तव में चला सकता है। उदाहरण के लिए:

अगर मेरे पास मैट्रिक्स एक्स है, तो निम्नानुसार है:

  > x <- matrix(1:8, nrow=4, ncol=2, dimnames=list(c("A","B","C","D"), c("x","y")) > x xy A 1 5 B 2 6 C 3 7 D 4 8 > 

मैं इसे 8 पंक्तियों के साथ एक डाटाफ्रेम में कैसे बदल सकता हूं, और 'पंक्ति', 'कर्नल' और 'मूल्य' नाम वाले तीन कॉलमों को 'पंक्ति' और 'कर्नल' के मूल्यों के रूप में आयाम नामों को कैसे जोड़ सकता हूं:

  > x.df row col value 1 A x 1 


(जिसके लिए उत्तर हो सकता है:

  > x.df <- reshape(data.frame(row=rownames(x), x), direction="long", varying=list(colnames(x)), times=colnames(x), v.names="value", timevar="col", idvar="row") 

)

छोटा शब्द विशेष रूप से महत्वपूर्ण है। आपको न्यूनतम प्रतिलिपि प्रस्तुत करने योग्य उदाहरण के लिए लक्ष्य करना चाहिए, जिसका अर्थ है कि समस्या का वर्णन करने के लिए डेटा और कोड उतना सरल होना चाहिए।

संपादित करें: बदसूरत कोड की तुलना में सुंदर कोड आसान है। एक शैली गाइड का उपयोग करें

R.2.14 के बाद से (मुझे लगता है) आप अपने डेटा टेक्स्ट प्रस्तुति सीधे readable को फ़ीड कर सकते हैं:

 df <- read.table(header=T, text="Sepal.Length Sepal.Width Petal.Length Petal.Width Species 1 5.1 3.5 1.4 0.2 setosa 2 4.9 3.0 1.4 0.2 setosa 3 4.7 3.2 1.3 0.2 setosa 4 4.6 3.1 1.5 0.2 setosa 5 5.0 3.6 1.4 0.2 setosa 6 5.4 3.9 1.7 0.4 setosa ") 

कभी-कभी समस्या वास्तव में डेटा के एक छोटे टुकड़े के साथ प्रतिलिपि प्रस्तुत करने योग्य नहीं होती है, चाहे आप कितना भी कठिन प्रयास करें, और सिंथेटिक डेटा के साथ नहीं हो (हालांकि यह दिखाने के लिए उपयोगी है कि आपने सिंथेटिक डेटा सेट कैसे बनाया जो समस्या को पुन: उत्पन्न नहीं करते, क्योंकि यह कुछ hypotheses नियमों)।

  • कहीं वेब पर डेटा पोस्ट करना और एक यूआरएल प्रदान करना आवश्यक हो सकता है
  • यदि जनता को जनता के लिए डेटा जारी नहीं किया जा सकता है, लेकिन इसे साझा किया जा सकता है, तो आप रुचि रखने वाले पार्टियों को ई-मेल करने की पेशकश कर सकते हैं (हालांकि यह उन लोगों की संख्या में कटौती करेगा जो काम करने के लिए परेशान होंगे इस पर)।
  • मैंने वास्तव में ऐसा नहीं देखा है, क्योंकि जो लोग अपने डेटा को जारी नहीं कर सकते हैं वे किसी भी रूप को जारी करने के बारे में संवेदनशील हैं, लेकिन ऐसा लगता प्रतीत होता है कि कुछ मामलों में कोई भी अभी भी डेटा पोस्ट कर सकता है अगर यह पर्याप्त रूप से अनाजीकृत / तहलका / भ्रष्ट था किसी तरह।

यदि आप इनमें से किसी भी काम नहीं कर सकते तो आपको शायद अपनी समस्या को हल करने के लिए सलाहकार को किराए पर लेना होगा …

संपादित करें : निनावीकरण / scrambling के लिए दो उपयोगी SO प्रश्न:

  • कैसे निजी डेटा से डेटा डेटा सेट बनाने के लिए (uninformative जगह धारकों के साथ चर नाम और स्तर की जगह)?
  • निरंतर बेवजह वितरण से प्राप्त यादृच्छिक संख्या का एक सेट देखते हुए वितरण को ढूंढें

उत्तर अब तक पुनरुत्पादन भाग के लिए स्पष्ट रूप से महान हैं। यह केवल स्पष्ट करने के लिए है कि एक प्रतिलिपि प्रस्तुत करने वाला उदाहरण एक प्रश्न का एकमात्र घटक नहीं होना चाहिए और नहीं होना चाहिए। यह समझाने के लिए मत भूलना कि आप इसे किस प्रकार देखना चाहते हैं और आपकी समस्या के रूपरेखा, न कि आपने अभी तक वहां कैसे पहुंचने का प्रयास किया है। कोड पर्याप्त नहीं है; आपको शब्द भी चाहिए

यहां से क्या करने से बचने का एक प्रतिलिपि प्रस्तुतकर्ता उदाहरण (वास्तविक उदाहरण से तैयार किया जाता है, निर्दोषों की रक्षा के लिए नाम बदलते हैं):


निम्नलिखित नमूना डेटा और फ़ंक्शन का हिस्सा है जिसमें मुझे समस्या है।

 code code code code code (40 or so lines of it) 

इसे कैसे प्राप्त किया जा सकता है ?


जल्दी से अपने डेटा का एक dput बनाने के लिए आप केवल अपने क्लिपबोर्ड पर डेटा (एक टुकड़ा) को कॉपी कर सकते हैं और आर में निम्न चला सकते हैं:

Excel में डेटा के लिए:

 dput(read.table("clipboard",sep="\t",header=TRUE)) 

एक txt फ़ाइल में डेटा के लिए:

 dput(read.table("clipboard",sep="",header=TRUE)) 

यदि आवश्यक हो तो आप बाद में sep बदल सकते हैं यह केवल तभी काम करेगा यदि आपका डेटा पाठ्यक्रम के क्लिपबोर्ड में है।

मेरे पास एक आर उदाहरण बनाने का एक बहुत आसान और कारगर तरीका है जो उपर्युक्त नहीं किया गया है आप सबसे पहले अपनी संरचना को परिभाषित कर सकते हैं। उदाहरण के लिए,

 mydata <- data.frame(a=character(0), b=numeric(0), c=numeric(0), d=numeric(0)) >fix(mydata) 

जब आप 'फिक्स' कमांड निष्पादित करते हैं, तो आपको यह पॉप-अप बॉक्स मिलेगा

तब आप अपने डेटा को मैन्युअल रूप से इनपुट कर सकते हैं। यह बड़े उदाहरणों के बजाय छोटे उदाहरणों के लिए कुशल है

पुनरुत्पादक कोड मदद पाने के लिए महत्वपूर्ण है हालांकि, ऐसे कई उपयोगकर्ता हैं जो शायद अपने डेटा का एक हिस्सा चिपकाने में संदेह हो सकते हैं। उदाहरण के लिए, वे संवेदनशील डेटा या एक शोध पत्र में उपयोग करने के लिए एकत्रित मूल डेटा पर काम कर सकते हैं। किसी भी कारण से, मैंने सोचा कि यह सार्वजनिक रूप से चिपकाने से पहले मेरे डेटा को "विकृत" करने के लिए एक आसान कार्य करने के लिए अच्छा होगा। पैकेज से dput फ़ंक्शन dput बहुत ही मूर्खतापूर्ण है, लेकिन मेरे लिए यह dput समारोह के साथ अच्छी तरह से काम करता है।

 install.packages("SciencesPo") dt <- data.frame( Z = sample(LETTERS,10), X = sample(1:10), Y = sample(c("yes", "no"), 10, replace = TRUE) ) > dt ZXY 1 D 8 no 2 T 1 yes 3 J 7 no 4 K 6 no 5 U 2 no 6 A 10 yes 7 Y 5 no 8 M 9 yes 9 X 4 yes 10 Z 3 no 

तो मैं इसे निमंत्रण देता हूं:

 > anonymize(dt) ZXY 1 b2 2.5 c1 2 b6 -4.5 c2 3 b3 1.5 c1 4 b4 0.5 c1 5 b7 -3.5 c1 6 b1 4.5 c2 7 b9 -0.5 c1 8 b5 3.5 c2 9 b8 -1.5 c2 10 b10 -2.5 c1 

निनामीकरण और डीटीटी कमांड लागू करने से पहले कोई भी पूरे डेटा के बजाय कुछ चर को नमूना देना चाह सकता है

  # sample two variables without replacement > anonymize(sample.df(dt,5,vars=c("Y","X"))) YX 1 a1 -0.4 2 a1 0.6 3 a2 -2.4 4 a1 -1.4 5 a2 3.6 

अक्सर आपको एक उदाहरण के लिए कुछ डेटा की आवश्यकता होती है, हालांकि, आप अपने सटीक डेटा पोस्ट नहीं करना चाहते हैं स्थापित पुस्तकालय में कुछ मौजूदा डेटा। फ्रेम का उपयोग करने के लिए, इसे आयात करने के लिए डेटा कमांड का उपयोग करें।

जैसे,

 data(mtcars) 

और फिर समस्या है

 names(mtcars) your problem demostrated on the mtcars data set 

Guidelines:


Your main objective in crafting your questions should be to make it as easy as possible for readers to understand and reproduce your problem on their systems. To do so:

  1. Provide input data
  2. Provide expected output
  3. Explain your problem succinctly
    • if you have over 20 lines of text + code you can probably go back and simplify
    • simplify your code as much as possible while preserving the problem/error

This does take some work but seems like a fair trade-off since you are asking others to do work for you.

Providing Data:


Built-in Data Sets

The best option by far is to rely on built-in datasets. This makes it very easy for others to work on your problem. Type data() at the R prompt to see what data is available to you. Some classic examples:

  • iris
  • mtcars
  • ggplot2::diamonds (external package, but almost everyone has it)

See this SO QA for how to find data sets suitable for your problem.

If you are able to rephrase your problem to use the built-in datasets you are much more likely to get good answers (and upvotes).

Self Generated Data

If your problem is very specific to a type of data that is not represented in the existing data sets, then provide the R code that generates the smallest possible dataset that your problem manifests itself on. For example

 set.seed(1) # important to make random data reproducible myData <- data.frame(a=sample(letters[1:5], 20, rep=T), b=runif(20)) 

Now someone trying to answer my question can copy/paste those two lines and start working on the problem immediately.

dput

As a last resort , you can use dput to transform a data object to R code (eg dput(myData) ). I say as a "last resort" because the output of dput is often fairly unwieldy, annoying to copy-paste, and obscures the rest of your question.

Provide Expected Output:


Someone once said:

A picture of expected output is worth 1000 words

— a very wise person

If you can add something like "I expected to get this result":

  cyl mean.hp 1: 6 122.28571 2: 4 82.63636 3: 8 209.21429 

to your question, people are much more likely to quickly understand what you are trying to do. If your expected result is large and unwieldy, then you probably haven't thought enough about how to simplify your problem (see next).

Explain Your Problem Succinctly


The main thing to do is to simplify your problem as much as possible before you ask your question. Re-framing the problem to work with the built-in datasets will help a lot in this regard. You will also often find that just by going through the process of simplification you will answer your own problem.

Here are some examples of good questions:

  • with built in data set
  • with user generated data

In both cases, the user's problems are almost certainly not with the simple examples they provide. Rather they abstracted the nature of their problem and applied it to a simple data set to ask their question.

Why Yet Another Answer To This Question?


This answer focuses on what I think is the best practice: use built-in data sets and provide what you expect as a result in a minimal form. The most prominent answers focus on other aspects. I don't expect this answer to rising to any prominence; this is here solely so that I can link to it in comments to newbie questions.

If you have large dataset which cannot be easily put to the script using dput() , post your data to pastebin and load them using read.table :

 d <- read.table("http://pastebin.com/raw.php?i=m1ZJuKLH") 

Inspired by @Henrik .

I am developing the wakefield package to address this need to quickly share reproducible data, sometimes dput works fine for smaller data sets but many of the problems we deal with are much larger, sharing such a large data set via dput is impractical.

About:

wakefield allows the user to share minimal code to reproduce data. The user sets n (number of rows) and specifies any number of preset variable functions (there are currently 70) that mimic real if data (things like gender, age, income etc.)

स्थापना:

Currently (2015-06-11), wakefield is a GitHub package but will go to CRAN eventually after unit tests are written. To install quickly, use:

 if (!require("pacman")) install.packages("pacman") pacman::p_load_gh("trinker/wakefield") 

Example:

Here is an example:

 r_data_frame( n = 500, id, race, age, sex, hour, iq, height, died ) 

This produces:

  ID Race Age Sex Hour IQ Height Died 1 001 White 33 Male 00:00:00 104 74 TRUE 2 002 White 24 Male 00:00:00 78 69 FALSE 3 003 Asian 34 Female 00:00:00 113 66 TRUE 4 004 White 22 Male 00:00:00 124 73 TRUE 5 005 White 25 Female 00:00:00 95 72 TRUE 6 006 White 26 Female 00:00:00 104 69 TRUE 7 007 Black 30 Female 00:00:00 111 71 FALSE 8 008 Black 29 Female 00:00:00 100 64 TRUE 9 009 Asian 25 Male 00:30:00 106 70 FALSE 10 010 White 27 Male 00:30:00 121 68 FALSE .. ... ... ... ... ... ... ... ... 

If you have one or more factor variable(s) in your data that you want to make reproducible with dput(head(mydata)) , consider adding droplevels to it, so that levels of factors that are not present in the minimized data set are not included in your dput output, in order to make the example minimal :

 dput(droplevels(head(mydata))) 

I wonder if an http://www.r-fiddle.org/ link could be a very neat way of sharing a problem. It receives a unique ID like and one could even think about embedding it in SO.

http://www.r-fiddle.org/#/help

Please do not paste your console outputs like this :

 If I have a matrix x as follows: > x <- matrix(1:8, nrow=4, ncol=2, dimnames=list(c("A","B","C","D"), c("x","y"))) > x xy A 1 5 B 2 6 C 3 7 D 4 8 > how can I turn it into a dataframe with 8 rows, and three columns named `row`, `col`, and `value`, which have the dimension names as the values of `row` and `col`, like this: > x.df row col value 1 A x 1 ... (To which the answer might be: > x.df <- reshape(data.frame(row=rownames(x), x), direction="long", + varying=list(colnames(x)), times=colnames(x), + v.names="value", timevar="col", idvar="row") ) 

We can not copy-paste it directly.

To make questions and answers properly reproducible, try to remove + & > before posting it and put # for outputs and comments like this:

 #If I have a matrix x as follows: x <- matrix(1:8, nrow=4, ncol=2, dimnames=list(c("A","B","C","D"), c("x","y"))) x # xy #A 1 5 #B 2 6 #C 3 7 #D 4 8 #how can I turn it into a dataframe with 8 rows, and three #columns named `row`, `col`, and `value`, which have the #dimension names as the values of `row` and `col`, like this: #x.df # row col value #1 A x 1 #... #To which the answer might be: x.df <- reshape(data.frame(row=rownames(x), x), direction="long", varying=list(colnames(x)), times=colnames(x), v.names="value", timevar="col", idvar="row") 

One more thing, if you have used any function from certain package, mention that library.

Here are some of my suggestions:

  • Try to use default R datasets
  • If you have your own dataset, include them with dput , so others can help you more easily
  • Do not use install.package() unless it is really necessary, people will understand if you just use require or library
  • Try to be concise,

    • Have some dataset
    • Try to describe the output you need as simply as possible
    • Do it yourself before you ask the question
  • It is easy to upload an image, so upload plots if you have
  • Also include any errors you may have

All these are part of a reproducible example.

Apart of all above answers which I found very interesting, it could sometimes be very easy as it is discussed here
http://www.dummies.com/how-to/content/how-to-make-a-minimal-reproducible-example-to-get-.html

There are many ways to make a random vector Create a 100 number vector with random values in R rounded to 2 decimals or random matrix in R

 mydf1<- matrix(rnorm(20),nrow=20,ncol=5) 

Note that sometimes it is very difficult to share a given data because of various reasons such as dimension etc. However, all above answers are great and very important to think and use when one wants to make a reproducible data example. But note that in order to make a data as representative as the original (in case the OP cannot share the original data), it is good to add some information with the data example as (if we call the data mydf1)

 class(mydf1) # this shows the type of the data you have dim(mydf1) # this shows the dimension of your data 

Moreover, one should know the type, length and attributes of a data which can be http://adv-r.had.co.nz/Data-structures.html

 #found based on the following typeof(mydf1), what it is. length(mydf1), how many elements it contains. attributes(mydf1), additional arbitrary metadata. #If you cannot share your original data, you can str it and give an idea about the structure of your data head(str(mydf1)) 

You can do this using reprex .

As mt1022 noted , "… good package for producing minimal, reproducible example is "reprex" from tidyverse ".

According to Tidyverse :

The goal of "reprex" is to package your problematic code in such a way that other people can run it and feel your pain.

An example is given on tidyverse web site.

 library(reprex) y <- 1:4 mean(y) reprex() 

I think this is the simplest way to create a reproducible example.

It's a good idea to use functions from the testthat package to show what you expect to occur. Thus, other people can alter your code until it runs without error. This eases the burden of those who would like to help you, because it means they don't have to decode your textual description. For example

 library(testthat) # code defining x and y if (y >= 10) { expect_equal(x, 1.23) } else { expect_equal(x, 3.21) } 

is clearer than "I think x would come out to be 1.23 for y equal to or exceeding 10, and 3.21 otherwise, but I got neither result". Even in this silly example, I think the code is clearer than the words. Using testthat lets your helper focus on the code, which saves time, and it provides a way for them to know they have solved your problem, before they post it