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




r-faq (16)

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

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

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

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


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

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

  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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

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

कुछ उदाहरण:

  • यादृच्छिक मान: सामान्य वितरण के लिए x <- runif(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.Date , as.xts , 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 आउटपुट 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 समूहबद्ध tbl_df (class grouped_df ) के लिए काम नहीं करेगा। इन मामलों में आप साझा करने से पहले नियमित डेटा फ्रेम में वापस परिवर्तित कर सकते हैं, 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)

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

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

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

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

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

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

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

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

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


चूंकि आर.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
") 

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


मैं पुन: उत्पादित डेटा को त्वरित रूप से साझा करने के लिए इस आवश्यकता को हल करने के लिए वेकफील्ड पैकेज विकसित कर रहा हूं, कभी-कभी छोटे डेटा सेट के लिए 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
.. ...   ... ...    ...      ... ...    ...   ...

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

dput(droplevels(head(mydata)))

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

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

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

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

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


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

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

कृपया इस तरह अपने कंसोल आउटपुट पेस्ट न करें:

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

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


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

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

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

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


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

एक यादृच्छिक वेक्टर बनाने के कई तरीके हैं, आर में दो यादृच्छिक मानों या यादृच्छिक मैट्रिक्स में यादृच्छिक मानों के साथ 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करने से कोड पर आपका सहायक फोकस हो जाता है, जो समय बचाता है, और यह उनके लिए यह जानने का एक तरीका प्रदान करता है कि उन्होंने आपकी समस्या हल कर ली है, इससे पहले कि वे इसे पोस्ट करें





r-faq