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


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

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

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

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


2381


मूल


मैं सवाल के दायरे के बारे में उलझन में हूँ। ऐसा लगता है कि लोग एसओ या आर-सहायता (कैसे "त्रुटि को पुन: उत्पन्न करें") पर प्रश्न पूछने में पुनरुत्पादित उदाहरण की व्याख्या पर कूद गए हैं। सहायता पृष्ठों में पुनरुत्पादित आर उदाहरणों के बारे में क्या? पैकेज डेमो में? ट्यूटोरियल / प्रस्तुतियों में? - baptiste
@baptiste: त्रुटि से भी कम है। मैंने समस्त सभी तकनीकों का उपयोग पैकेज सहायता पृष्ठों में किया है, और ट्यूटोरियल और प्रस्तुतियों में मैं आर के बारे में बताता हूं - Joris Meys
डेटा कभी-कभी सीमित कारक होता है, क्योंकि संरचना अनुकरण करने के लिए बहुत जटिल हो सकती है। निजी डेटा से सार्वजनिक डेटा का उत्पादन करने के लिए: stackoverflow.com/a/10458688/742447 में stackoverflow.com/questions/10454973/... - Etienne Low-Décarie


जवाब:


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

  • एक न्यूनतम डेटासेट, त्रुटि को पुन: उत्पन्न करने के लिए आवश्यक है
  • न्यूनतम runnable त्रुटि को पुन: उत्पन्न करने के लिए आवश्यक कोड, जिसे दिए गए डेटासेट पर चलाया जा सकता है।
  • प्रयुक्त पैकेज, आर संस्करण, और सिस्टम पर आवश्यक जानकारी यह चल रही है।
  • यादृच्छिक प्रक्रियाओं के मामले में, एक बीज (द्वारा निर्धारित 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)

Matrices के लिए, कोई भी उपयोग कर सकते हैं matrix()उदाहरण के लिए:

matrix(1:10, ncol = 2)

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

एक उदाहरण :

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

कुछ प्रश्नों के लिए, विशिष्ट प्रारूपों की आवश्यकता हो सकती है। इनके लिए, कोई भी प्रदान किए गए किसी भी का उपयोग कर सकता है as.someType कार्य: 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 वस्तुओं या समूह के लिए tbl_df (कक्षा grouped_df) से dplyr। इन मामलों में आप साझा करने से पहले नियमित डेटा फ्रेम में वापस परिवर्तित कर सकते हैं, dput(as.data.frame(my_data))

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

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)

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

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

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

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

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

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

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

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

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


1454



आप कैसे उपयोग करते हैं dput यदि डेटाफ्रेम बहुत बड़ा है और डेटाफ्रेम के बीच में समस्या उत्पन्न होती है? उपयोग करने का कोई तरीका है dput आंकड़ों के मध्य भाग को पुन: उत्पन्न करने के लिए, 60 से 70 पंक्तियों का कहना है? - BgnR
@BgnR आप इंडेक्स का उपयोग कर डेटा फ्रेम का हिस्सा निकाल सकते हैं, उदाहरण के लिए: tmp <- mydf[50:70,] के बाद dput(mydf)। यदि डेटा फ्रेम वास्तव में बड़ा है, तो समस्या को अलग करने का प्रयास करें और समस्या का कारण बनने वाली कुछ पंक्तियां सबमिट करें। - Joris Meys
@ जोरीसमेस: क्या बताने का कोई तरीका है head या dput डेटा को एन रिकर्सिवली से सीमित करने के लिए? मैं पुनरुत्पादित उदाहरण के साथ आने की कोशिश कर रहा हूं और मेरा डेटा डेटा फ्रेम की एक सूची है। इसलिए, dput(head(myDataObj)) ऐसा लगता है कि यह पर्याप्त नहीं है, क्योंकि यह 14 एमबी आकार की आउटपुट फ़ाइल उत्पन्न करता है। - Aleksandr Blekh
@ जोरीसमेस: बस एफवाईआई - उपरोक्त टिप्पणी में एक अलग प्रश्न के रूप में प्रश्न पोस्ट किया गया: stackoverflow.com/questions/25127026/...। - Aleksandr Blekh
@ कोनराड सबसे अच्छी चीज जो आप कर सकते हैं, फ़ाइल से लिंक है और उस फ़ाइल में पढ़ने के लिए न्यूनतम आदेश दें। यह dput () के आउटपुट को कॉपी-पेस्ट करने से कम परेशानी होगी :) - Joris Meys


(यहां से मेरी सलाह है पुनरुत्पादित उदाहरण कैसे लिखें । मैंने इसे छोटा लेकिन मीठा बनाने की कोशिश की है)

पुनरुत्पादित उदाहरण कैसे लिखें।

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

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

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

  • शामिल करने का सबसे आसान तरीका डेटा एक ईमेल या स्टैक ओवरफ़्लो प्रश्न का उपयोग करना है dput() पैदा करना इसे फिर से बनाने के लिए आर कोड। उदाहरण के लिए, फिर से बनाने के लिए mtcars आर में डेटासेट, मैं निम्नलिखित कदम उठाऊंगा:

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

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

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

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

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

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

अपने सभी कोड को ईमेल में डालने से पहले, इसे डालने पर विचार करें जिस्ट जिथब । यह आपके कोड को अच्छा सिंटैक्स हाइलाइटिंग देगा, और आपको ईमेल सिस्टम द्वारा उलझन में आने वाली चीज़ों के बारे में चिंता करने की ज़रूरत नहीं है।


514



reprex में tidyverseन्यूनतम, पुनरुत्पादित उदाहरण बनाने के लिए एक अच्छा पैकेज है: github.com/tidyverse/reprex - mt1022
कोई भी ईमेल को कोड में क्यों रखेगा? - Gilgamesh
मैं नियमित रूप से उनसे कोड के साथ ईमेल प्राप्त करता हूं। मुझे संलग्न शब्द दस्तावेज़ों के साथ ईमेल भी प्राप्त होते हैं जिनमें कोड होता है। कभी-कभी मुझे संलग्न शब्द दस्तावेज़ों के साथ ईमेल भी मिलते हैं जिनमें कोड के स्क्रीनशॉट होते हैं। - hadley


व्यक्तिगत रूप से, मैं "एक" लाइनर पसंद करते हैं। लाइनों के साथ कुछ:

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, आप "स्थानिक" पैकेजों में बाहरी फ़ाइलों (जैसे ESRI shapefile) के माध्यम से कुछ डेटासेट प्राप्त कर सकते हैं (कार्य दृश्यों में स्थानिक दृश्य देखें)।

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

258



IMHO, उपयोग करते समय sample या runif यह समझदार है set.seed। कम से कम, नमूना या यादृच्छिक संख्या पीढ़ी पर रिलेइंग उदाहरणों का उत्पादन करते समय मुझे यह सुझाव मिला है। - Konrad
@ कोनराड मैं सहमत हूं, लेकिन यह निर्भर हो सकता है। यदि आप केवल कुछ संख्याएं उत्पन्न करने की कोशिश कर रहे हैं तो बीज की आवश्यकता नहीं हो सकती है, लेकिन यदि आप कुछ विशिष्ट समझने की कोशिश कर रहे हैं जहां निश्चित संख्या की आवश्यकता है, तो बीज अनिवार्य होगा। - Roman Luštrik


इस पोस्ट से प्रेरित, अब मैं एक आसान काम का उपयोग करता हूं
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==

241





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

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

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

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

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


168





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

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

यदि मेरे पास एक मैट्रिक्स एक्स निम्नानुसार है:

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

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

  > 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")

)

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

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


142





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

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
") 

136



आप भी उपयोग कर सकते हैं read.table("clipboard", header=TRUE)। - sebastian-c
@ सेबेस्टियन-सी पुनरुत्पादित उदाहरण बनाने के लिए यह कैसे अच्छा है ?? :) - TMS
@ टीएमएस ने गंभीर विचार दिया, अगर पूछने वाले ने डेटा की आपूर्ति की है और समस्या छोटी है (लेकिन कुछ समाधान हो सकते हैं), तो यह तेज़ हो सकता है और आप अभी भी सभी चरणों का पालन कर सकते हैं। - sebastian-c


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

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

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

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


126



सिंथेटिक डेटा सेट बनाने के लिए, इस सवाल का जवाब के अनुप्रयोगों सहित उपयोगी उदाहरण दें fitdistr तथा fitdistrplus। - Iterator


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

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


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

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

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



115