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




r-faq (19)

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

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

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

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

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

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

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

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


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

यदि आपके पास बड़ा डेटासेट है जिसे आसानी से dput() का उपयोग करके स्क्रिप्ट में नहीं रखा जा सकता है, तो अपना डेटा dput() पोस्ट करें और dput() का उपयोग read.table उन्हें लोड करें:

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

@Henrik से प्रेरित


यहां मेरे कुछ सुझाव दिए गए हैं:

  • डिफ़ॉल्ट आर डेटासेट का उपयोग करने का प्रयास करें
  • यदि आपके पास अपना खुद का डेटासेट है dput, तो उन्हें शामिल करें , इसलिए अन्य आपकी मदद कर सकते हैं
  • install.package()जब तक यह वास्तव में जरूरी नहीं है तब तक इसका उपयोग न करें , अगर आप अभी उपयोग करते हैं requireया लोग समझेंगेlibrary
  • संक्षेप में रहने की कोशिश करो,

    • कुछ डेटासेट है
    • जितनी जल्दी संभव हो सके आउटपुट का वर्णन करने का प्रयास करें
    • सवाल पूछने से पहले इसे स्वयं करें
  • एक छवि अपलोड करना आसान है, इसलिए यदि आपके पास प्लॉट अपलोड करें
  • आपके पास होने वाली किसी भी त्रुटि को भी शामिल करें

ये सभी एक पुनरुत्पादित उदाहरण का हिस्सा हैं।


मैं पुन: उत्पादित डेटा को त्वरित रूप से साझा करने के लिए इस आवश्यकता को हल करने के लिए वेकफील्ड पैकेज विकसित कर रहा हूं, कभी-कभी छोटे डेटा सेट के लिए dput काम ठीक करता है लेकिन हम जिन समस्याओं से निपटते हैं उनमें से कई समस्याएं बहुत बड़ी हैं, dput माध्यम से इस तरह के एक बड़े डेटा सेट को अव्यवहारिक है।

के बारे में:

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

स्थापना:

वर्तमान में (2015-06-11), वेकफील्ड एक गिटहब पैकेज है लेकिन यूनिट परीक्षणों के लिखे जाने के बाद सीआरएएन में जाएगा। जल्दी से स्थापित करने के लिए, उपयोग करें:

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

उदाहरण:

यहाँ एक उदाहरण है:

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

यह पैदा करता है:

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

हम इसे सीधे कॉपी नहीं कर सकते हैं।

प्रश्नों और उत्तरों को उचित रूप से पुन: उत्पन्न करने के लिए, इसे पोस्ट करने से पहले हटाने +और >इसे हटाने और #इस तरह के आउटपुट और टिप्पणियों के लिए डालने का प्रयास करें:

#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
#  x y
#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")

एक और बात, अगर आपने कुछ पैकेज से किसी भी फ़ंक्शन का उपयोग किया है, तो उस लाइब्रेरी का उल्लेख करें।


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

install.packages("SciencesPo")

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

> dt
   Z  X   Y
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)
     Z    X  Y
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")))
   Y    X
1 a1 -0.4
2 a1  0.6
3 a2 -2.4
4 a1 -1.4
5 a2  3.6

अपने डेटा का एक त्वरित रूप से बनाने के लिए आप डेटा को अपने क्लिपबोर्ड पर कॉपी कर सकते हैं और निम्नलिखित में चला सकते हैं:

एक्सेल में डेटा के लिए:

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

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

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

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


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

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

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

उपर्युक्त उत्तरों के अलावा जो मुझे बहुत दिलचस्प लगता है, कभी-कभी यह बहुत आसान हो सकता है क्योंकि यहां पर चर्चा की गई है: - आर के साथ सहायता प्राप्त करने के लिए एक न्यूनतम अनुमोदित उदाहरण कैसे बनाएं

एक यादृच्छिक वेक्टर बनाने के कई तरीके हैं, आर में दो यादृच्छिक मानों या यादृच्छिक मैट्रिक्स में यादृच्छिक मानों के साथ 100 नंबर वेक्टर बनाएं

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

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

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

इसके अलावा, किसी को डेटा के प्रकार, लंबाई और विशेषताओं को जानना चाहिए जो डेटा संरचनाएं हो सकती हैं

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

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

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

"मुझे लगता है कि x के बराबर 1.23 के बराबर या 10 से अधिक, और 3.21 अन्यथा होगा, लेकिन मुझे नतीजा नहीं मिला"। यहां तक ​​कि इस मूर्ख उदाहरण में, मुझे लगता है कि कोड शब्दों की तुलना में स्पष्ट है। उपयोग testthatकरने से कोड पर आपका सहायक फोकस हो जाता है, जो समय बचाता है, और यह उनके लिए यह जानने का एक तरीका प्रदान करता है कि उन्होंने आपकी समस्या हल कर ली है, इससे पहले कि वे इसे पोस्ट करें


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

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

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

  > 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', और 'value' नामक तीन कॉलम, जिनमें आयाम नाम 'पंक्ति' और '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")

)

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

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


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

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

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

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

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


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

जैसे,

data(mtcars)

और फिर समस्या करो

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

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

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

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

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

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


दिशानिर्देश:

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

  1. इनपुट डेटा प्रदान करें
  2. अपेक्षित आउटपुट प्रदान करें
  3. संक्षेप में अपनी समस्या की व्याख्या करें
    • यदि आपके पास टेक्स्ट + कोड की 20 से अधिक पंक्तियां हैं तो आप शायद वापस जा सकते हैं और सरल बना सकते हैं
    • समस्या / त्रुटि को संरक्षित करते समय जितना संभव हो सके अपने कोड को सरल बनाएं

यह कुछ काम करता है लेकिन एक उचित व्यापार-बंद की तरह लगता है क्योंकि आप दूसरों से आपके लिए काम करने के लिए कह रहे हैं।

डेटा प्रदान करना:

अंतर्निहित डेटा सेट्स

अब तक का सबसे अच्छा विकल्प अंतर्निहित डेटासेट पर भरोसा करना है। यह दूसरों के लिए आपकी समस्या पर काम करना बहुत आसान बनाता है। यह देखने के लिए कि कौन सा डेटा आपके लिए उपलब्ध है, आर प्रॉम्प्ट पर data() टाइप data() । कुछ क्लासिक उदाहरण:

  • iris
  • mtcars
  • ggplot2::diamonds (बाहरी पैकेज, लेकिन लगभग हर किसी के पास यह है)

अपनी समस्या के लिए उपयुक्त डेटा सेट कैसे ढूंढें इस एसओ क्यूए को देखें।

यदि आप अंतर्निहित डेटासेट का उपयोग करने के लिए अपनी समस्या को फिर से भरने में सक्षम हैं, तो आपको अच्छे उत्तरों (और अपवॉट) प्राप्त होने की अधिक संभावना है।

स्वयं उत्पन्न डेटा

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

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

अब कोई मेरे प्रश्न का उत्तर देने का प्रयास कर रहा है, उन दो पंक्तियों को कॉपी / पेस्ट कर सकता है और तुरंत समस्या पर काम करना शुरू कर सकता है।

dput

अंतिम उपाय के रूप में , आप डेटा ऑब्जेक्ट को आर कोड में बदलने के लिए dput का उपयोग कर सकते हैं (उदाहरण के लिए dput(myData) )। मैं एक "अंतिम उपाय" के रूप में कहता हूं क्योंकि dput का उत्पादन अक्सर काफी dput होता है, कॉपी-पेस्ट करने के लिए परेशान होता है, और आपके बाकी प्रश्नों को अस्पष्ट करता है।

अपेक्षित आउटपुट प्रदान करें:

किसी ने एक बार कहा:

अपेक्षित आउटपुट की एक तस्वीर 1000 शब्दों के लायक है

- एक बहुत बुद्धिमान व्यक्ति

यदि आप कुछ ऐसा जोड़ सकते हैं जैसे "मुझे यह परिणाम प्राप्त होने की उम्मीद है":

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

आपके प्रश्न के लिए, लोगों को जल्दी से समझने की संभावना है कि आप क्या करने की कोशिश कर रहे हैं। यदि आपका अपेक्षित परिणाम बड़ा और अनावश्यक है, तो संभवतः आपने अपनी समस्या को सरल बनाने के बारे में पर्याप्त नहीं सोचा है (अगला देखें)।

संक्षेप में अपनी समस्या की व्याख्या करें

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

अच्छे प्रश्नों के कुछ उदाहरण यहां दिए गए हैं:

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

इस सवाल का एक और जवाब क्यों?

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


मुझे आश्चर्य है कि एक http://old.r-fiddle.org/ लिंक किसी समस्या को साझा करने का एक बहुत साफ तरीका हो सकता है। यह एक अद्वितीय आईडी प्राप्त करता है और कोई भी इसे SO में एम्बेड करने के बारे में सोच सकता है।


आप github.com/tidyverse/reprex का उपयोग कर ऐसा कर सकते हैं ।

के रूप में mt1022 उल्लेख किया , "... कम से कम, प्रतिलिपि प्रस्तुत करने योग्य उदाहरण के उत्पादन के लिए अच्छा पैकेज है " reprex " से tidyverse "।

Tidyverse के अनुसार :

"Reprex" का लक्ष्य अपने समस्याग्रस्त कोड को इस तरह से पैकेज करना है कि अन्य लोग इसे चला सकें और आपका दर्द महसूस कर सकें।

एक उदाहरण पर दिया जाता है tidyverse वेब साइट।

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

मुझे लगता है कि यह पुनरुत्पादित उदाहरण बनाने का सबसे आसान तरीका है।


यदि आपके डेटा में एक या अधिक factor चर (ओं) हैं जो आप dput(head(mydata)) साथ पुन: उत्पन्न करना चाहते हैं, तो इसमें droplevels को जोड़ने पर विचार करें, ताकि कम से कम डेटा सेट में मौजूद कारकों के स्तर न हों उदाहरण को न्यूनतम बनाने के लिए, अपने dput आउटपुट में शामिल नहीं है:

dput(droplevels(head(mydata)))






r-faq