with - sostituire valori in r




Come fare un grande esempio riproducibile di R (16)

Quando si parla di prestazioni con colleghi, insegnamento, invio di una segnalazione di bug o ricerca di indicazioni sulle mailing list e qui su Stack Overflow, viene spesso chiesto e sempre utile un esempio riproducibile .

Quali sono i tuoi consigli per creare un esempio eccellente? Come si incolla la struttura dei dati da r in un formato di testo? Quali altre informazioni dovresti includere?

Ci sono altri trucchi oltre a usare dput() , dump() o structure() ? Quando dovresti includere le istruzioni library() o require() ? Quali parole riservate dovrebbero evitare, oltre a c , df , data , ecc.?

Come si fa un grande esempio riproducibile?


Linee guida:

Il tuo obiettivo principale nel creare le tue domande dovrebbe essere quello di rendere il più semplice possibile per i lettori capire e riprodurre il tuo problema sui loro sistemi. Fare così:

  1. Fornire dati di input
  2. Fornire l'output previsto
  3. Spiega il tuo problema in modo sintetico
    • se hai più di 20 righe di testo + codice puoi probabilmente tornare indietro e semplificare
    • semplifica il tuo codice il più possibile preservando il problema / errore

Questo richiede un po 'di lavoro, ma sembra un compromesso equo dal momento che chiedi agli altri di lavorare per te.

Fornire dati:

Set di dati integrati

L'opzione migliore è di fare affidamento su set di dati integrati. Questo rende molto facile per gli altri lavorare sul tuo problema. Digitare data() al prompt R per vedere quali dati sono disponibili. Alcuni esempi classici:

  • iris
  • mtcars
  • ggplot2::diamonds (pacchetto esterno, ma quasi tutti ggplot2::diamonds hanno)

Vedi questo SO QA per come trovare set di dati adatti al tuo problema.

Se si è in grado di riformulare il problema per utilizzare i set di dati incorporati, è molto più probabile ottenere buone risposte (e upvotes).

Dati generati automaticamente

Se il tuo problema è molto specifico per un tipo di dati che non è rappresentato nei set di dati esistenti, quindi fornire il codice R che genera il set di dati più piccolo possibile che si manifesta il problema. Per esempio

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

Ora qualcuno che sta cercando di rispondere alla mia domanda può copiare / incollare queste due righe e iniziare subito a lavorare sul problema.

dput

Come ultima risorsa , è possibile utilizzare dput per trasformare un oggetto dati in codice R (ad esempio dput(myData) ). Dico come "ultima risorsa" perché l'output di dput è spesso abbastanza ingombrante, fastidioso di copiare e incollare e oscura il resto della domanda.

Fornire output atteso:

Qualcuno ha detto una volta:

Un'immagine dell'output atteso vale 1000 parole

- una persona molto saggia

Se puoi aggiungere qualcosa come "Mi aspettavo di ottenere questo risultato":

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

alla tua domanda, le persone hanno molte più probabilità di capire rapidamente cosa stai cercando di fare. Se il risultato atteso è ampio e poco pratico, probabilmente non hai pensato abbastanza su come semplificare il tuo problema (vedi successivo).

Spiega il tuo problema in modo succinto

La cosa principale da fare è semplificare il più possibile il tuo problema prima di porre la tua domanda. Ri-inquadrare il problema per lavorare con i set di dati integrati aiuterà molto in questo senso. Spesso scoprirai che solo passando attraverso il processo di semplificazione rispondi al tuo problema.

Ecco alcuni esempi di buone domande:

In entrambi i casi, i problemi dell'utente non sono quasi certamente con i semplici esempi forniti. Piuttosto hanno sottratto la natura del loro problema e lo hanno applicato a un semplice set di dati per porre la loro domanda.

Perché ancora un'altra risposta a questa domanda?

Questa risposta si concentra su ciò che ritengo sia la migliore pratica: utilizzare set di dati integrati e fornire ciò che ci si aspetta come risultato in una forma minima. Le risposte più importanti si concentrano su altri aspetti. Non mi aspetto che questa risposta aumenti di rilievo; questo è qui solo in modo che io possa collegarlo ai commenti alle domande dei principianti.


(Ecco il mio consiglio su Come scrivere un esempio riproducibile . Ho cercato di renderlo breve ma dolce)

Come scrivere un esempio riproducibile.

È più probabile che tu abbia un buon aiuto con il tuo problema R se fornisci un esempio riproducibile. Un esempio riproducibile consente a qualcun altro di ricreare il tuo problema semplicemente copiando e incollando il codice R.

Ci sono quattro cose che devi includere per rendere riproducibile il tuo esempio: pacchetti richiesti, dati, codice e una descrizione del tuo ambiente R.

  • I pacchetti dovrebbero essere caricati nella parte superiore dello script, quindi è facile vedere quali sono necessari per l'esempio.

  • Il modo più semplice per includere i dati in una email o una domanda di overflow dello stack è usare dput() per generare il codice R per ricrearlo. Ad esempio, per ricreare il set di dati mtcars in R, mtcars i seguenti passi:

    1. Esegui dput(mtcars) in R
    2. Copia l'output
    3. Nel mio script riproducibile, scrivi mtcars <- quindi incolla.
  • Spendi un po 'di tempo per assicurarti che il tuo codice sia facile da leggere per gli altri:

    • assicurati di aver usato spazi e i nomi delle variabili sono concisi, ma informativo

    • usa i commenti per indicare dove si trova il tuo problema

    • fai del tuo meglio per rimuovere tutto ciò che non è correlato al problema.
      Più corto è il tuo codice, più facile è capire.

  • Includere l'output di sessionInfo() in un commento nel codice. Questo riassume l' ambiente R e semplifica la verifica della presenza di un pacchetto scaduto.

Puoi verificare se hai effettivamente fatto un esempio riproducibile avviando una nuova sessione R e incollando il tuo script in.

Prima di inserire tutto il tuo codice in un'email, valuta se metterlo in Github Gist . Darà al tuo codice una bella evidenziazione della sintassi, e non dovrai preoccuparti di qualcosa che viene manomesso dal sistema di posta elettronica.


Dal momento che R.2.14 (immagino) è possibile alimentare la rappresentazione del testo dei dati direttamente in 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
") 

Ecco una buona guida:

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

Ma la cosa più importante è: assicurati di creare una piccola porzione di codice che possiamo eseguire per vedere qual è il problema. Una funzione utile per questo è dput() , ma se hai dati molto grandi potresti voler creare un piccolo set di dati campione o usare solo le prime 10 linee o giù di lì.

MODIFICARE:

Assicurati anche di aver identificato dove si trova il problema. L'esempio non dovrebbe essere un intero script R con "Sulla riga 200 c'è un errore". Se si utilizzano gli strumenti di debug in R (I love browser() ) e google si dovrebbe essere in grado di identificare realmente dove si trova il problema e riprodurre un esempio banale in cui la stessa cosa va storta.


Il codice riproducibile è la chiave per ottenere aiuto. Tuttavia, ci sono molti utenti che potrebbero essere scettici di incollare anche una parte dei loro dati. Ad esempio, potrebbero lavorare con dati sensibili o su dati originali raccolti da utilizzare in un documento di ricerca. Per qualsiasi motivo, ho pensato che sarebbe stato utile avere una comoda funzione per "deformare" i miei dati prima di incollarli pubblicamente. La funzione anonymize dal pacchetto SciencesPo è molto sciocca, ma per me funziona bene con la funzione 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

Quindi lo anonimizzo:

> 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

Si potrebbe anche voler campionare alcune variabili anziché i dati interi prima di applicare l'anonimato e il comando dput.

    # 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

Ispirato da questo stesso post, ora uso una comoda funzione
reproduce(<mydata>) quando ho bisogno di postare su .

ISTRUZIONI RAPIDE

Se myData è il nome dell'oggetto da riprodurre, eseguire quanto segue in R:

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

reproduce(myData)

Dettagli:

Questa funzione è un wrapper intelligente per dput e fa quanto segue:

  • campiona automaticamente un set di dati di grandi dimensioni (in base a dimensioni e classe. La dimensione del campione può essere regolata)
  • crea un output dput
  • ti consente di specificare quali colonne esportare
  • aggiunge in primo piano objName <- ... modo che possa essere facilmente copiato + incollato, ma ...
  • Se lavori su un Mac, l'output viene copiato automaticamente negli Appunti, in modo che tu possa semplicemente eseguirlo e quindi incollarlo nella tua domanda.

La fonte è disponibile qui:

Esempio:

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

DF è di circa 100 x 102. Voglio campionare 10 righe e alcune colonne specifiche

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

Fornisce il seguente risultato:

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==

Si noti inoltre che l'interezza dell'output è in una bella singola, lunga linea, non in un alto paragrafo di linee tritate. In questo modo è più facile leggere i post delle domande SO e anche più facile copiare e incollare.

Aggiornamento ottobre 2013:

Ora puoi specificare il numero di righe di testo in uscita (ovvero, cosa incollerai in ). Usa l'argomento lines.out=n per questo. Esempio:

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

    ==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==

Le risposte finora sono ovviamente grandi per la parte di riproducibilità. Questo è solo per chiarire che un esempio riproducibile non può e non dovrebbe essere l'unico componente di una domanda. Non dimenticare di spiegare che cosa vuoi che assomigli e i contorni del tuo problema, non solo come hai tentato di arrivare fin lì. Il codice non è abbastanza; hai bisogno anche di parole.

Ecco un esempio riproducibile di cosa evitare di fare (tratto da un esempio reale, i nomi modificati per proteggere l'innocente):

Quanto segue sono dati di esempio e parte della funzione con cui ho problemi.

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

Come posso raggiungere questo obiettivo ?


Mi chiedo se un link http://old.r-fiddle.org/ potrebbe essere un modo molto pulito di condividere un problema. Riceve un ID univoco come e si potrebbe anche pensare di incorporarlo in SO.


Personalmente, preferisco le fodere "una". Qualcosa in questo modo:

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)

La struttura dei dati dovrebbe imitare l'idea del problema dello scrittore e non l'esatta struttura verbale. Lo apprezzo molto quando le variabili non sovrascrivono le mie variabili o Dio non voglia, funzioni (come df ).

In alternativa, è possibile tagliare alcuni angoli e puntare a un set di dati preesistente, ad esempio:

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

Non dimenticare di menzionare eventuali pacchetti speciali che potresti utilizzare.

Se stai cercando di dimostrare qualcosa su oggetti più grandi, puoi provare

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

Se stai lavorando con dati spaziali tramite il pacchetto raster , puoi generare alcuni dati casuali. Un sacco di esempi possono essere trovati nella vignetta del pacchetto, ma ecco un piccolo nugget.

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)

Se hai bisogno di qualche oggetto territoriale come implementato in sp , puoi ottenere alcuni set di dati tramite file esterni (come lo shapefile ESRI) in pacchetti "spaziali" (vedi la vista Spatial in Task Views).

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

Se si dispone di un set di dati di grandi dimensioni che non può essere facilmente inserito nello script utilizzando dput() , inserire i dati in pastebin e caricarli utilizzando read.table :

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

Ispirato da @Henrik .


Si prega di non incollare le uscite della console in questo modo:

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

Non possiamo copiare e incollare direttamente.

Per rendere le domande e le risposte correttamente riproducibili, provare a rimuovere +e >prima di postarlo e inserire #output e commenti come questo:

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

Un'altra cosa, se hai usato qualche funzione da un certo pacchetto, menziona quella libreria.


Spesso hai bisogno di alcuni dati per un esempio, tuttavia, non vuoi pubblicare i tuoi dati esatti. Per utilizzare alcuni data.frame esistenti nella libreria stabilita, utilizzare il comando dati per importarlo.

per esempio,

data(mtcars)

e poi fai il problema

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

Un esempio riproducibile minimo è costituito dai seguenti elementi:

  • un set di dati minimo, necessario per riprodurre l'errore
  • il codice minimo eseguibile necessario per riprodurre l'errore, che può essere eseguito sul set di dati specificato.
  • le informazioni necessarie sui pacchetti usati, la versione R e il sistema su cui è in esecuzione.
  • nel caso di processi casuali, un seme (impostato da set.seed() ) per la riproducibilità

Guardare gli esempi nei file di aiuto delle funzioni utilizzate è spesso utile. In generale, tutto il codice fornito soddisfa i requisiti di un esempio riproducibile minimo: i dati vengono forniti, viene fornito un codice minimo e tutto è eseguibile.

Produrre un set di dati minimo

Per la maggior parte dei casi, questo può essere fatto facilmente semplicemente fornendo un vettore / frame dati con alcuni valori. Oppure puoi utilizzare uno dei set di dati incorporati, che sono forniti con la maggior parte dei pacchetti.
Un elenco completo di set di dati integrati può essere visto con la library(help = "datasets") . C'è una breve descrizione per ogni set di dati e ulteriori informazioni possono essere ottenute per esempio con ?mtcars dove 'mtcars' è uno dei set di dati nella lista. Altri pacchetti potrebbero contenere set di dati aggiuntivi.

Fare un vettore è facile. A volte è necessario aggiungere un po 'di casualità ad esso, e ci sono un numero intero di funzioni per farlo. sample() può randomizzare un vettore o dare un vettore casuale con pochi valori. letters sono un vettore utile che contiene l'alfabeto. Questo può essere usato per fare fattori.

Alcuni esempi:

  • valori casuali: x <- rnorm(10) per la distribuzione normale, x <- runif(10) per la distribuzione uniforme, ...
  • una permutazione di alcuni valori: x <- sample(1:10) per il vettore 1:10 in ordine casuale.
  • un fattore casuale: x <- sample(letters[1:4], 20, replace = TRUE)

Per le matrici, si può usare matrix() , ad esempio:

matrix(1:10, ncol = 2)

La creazione di frame di dati può essere eseguita utilizzando data.frame() . Si dovrebbe prestare attenzione a nominare le voci nel riquadro dati e non renderlo eccessivamente complicato.

Un esempio :

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

Per alcune domande, possono essere necessari formati specifici. Per questi, è possibile utilizzare qualsiasi delle funzioni as.someType fornite: as.factor , as.Date , as.xts , ... Queste in combinazione con i trucchi vettore e / o frame dati.

Copia i tuoi dati

Se hai alcuni dati che sarebbero troppo difficili da costruire usando questi suggerimenti, puoi sempre creare un sottoinsieme dei tuoi dati originali, usando ad esempio head() , subset() o gli indici. Quindi usa eg. dput() per darci qualcosa che può essere messo in R immediatamente:

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

Se il tuo frame di dati ha un fattore con molti livelli, l'output di dput può essere ingombrante perché elenca ancora tutti i possibili livelli di fattore anche se non sono presenti nel sottoinsieme dei tuoi dati. Per risolvere questo problema, puoi utilizzare la funzione droplevels() . Si noti sotto come le specie sono un fattore con un solo livello:

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

Un altro avvertimento per dput è che non funzionerà per data.table oggetti data.table chiave o per il gruppo tbl_df (classe grouped_df ) da dplyr . In questi casi è possibile riconvertire in un normale frame di dati prima di condividere, dput(as.data.frame(my_data)) .

Nel peggiore dei casi, puoi dare una rappresentazione di testo che può essere letta usando il parametro text di 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)

Produrre codice minimo

Questa dovrebbe essere la parte facile, ma spesso non lo è. Quello che non dovresti fare è:

  • aggiungi tutti i tipi di conversione dei dati. Assicurati che i dati forniti siano già nel formato corretto (a meno che non sia questo il problema, ovviamente)
  • copia-incolla un'intera funzione / pezzo di codice che dà un errore. Innanzitutto, cerca di individuare le righe che determinano esattamente l'errore. Molto spesso scoprirai qual è il problema te stesso.

Cosa dovresti fare, è:

  • aggiungi quali pacchetti dovrebbero essere usati se ne usi (usando library() )
  • se apri connessioni o crei file, aggiungi del codice per chiuderli o eliminare i file (usando unlink() )
  • se si modificano le opzioni, assicurarsi che il codice contenga un'istruzione per ripristinarle su quelle originali. (es. op <- par(mfrow=c(1,2)) ...some code... par(op) )
  • prova esegui il tuo codice in una nuova sessione R vuota per assicurarti che il codice sia eseguibile. Le persone dovrebbero essere in grado di copiare e incollare i dati e il codice nella console e ottenere esattamente la stessa cosa che hai.

Dare informazioni extra

Nella maggior parte dei casi, saranno sufficienti solo la versione R e il sistema operativo. Quando sorgono conflitti con i pacchetti, dare l'output di sessionInfo() può davvero aiutare. Quando si parla di connessioni ad altre applicazioni (tramite ODBC o altro), è necessario fornire anche i numeri di versione e, se possibile, anche le informazioni necessarie sulla configurazione.

Se stai usando R in R Studio usando rstudioapi::versionInfo() può essere utile segnalare la versione di RStudio.

Se hai un problema con un pacchetto specifico, potresti voler fornire la versione del pacchetto dando l'output di packageVersion("name of the package") .


Ecco alcuni dei miei suggerimenti:

  • Prova ad usare set di dati R predefiniti
  • Se disponi di un set di dati personalizzato, includili, in dputmodo che altri possano aiutarti più facilmente
  • Non usare a install.package()meno che non sia veramente necessario, le persone capiranno se usi requireo sololibrary
  • Cerca di essere conciso,

    • Avere un dataset
    • Cerca di descrivere l'output di cui hai bisogno nel modo più semplice possibile
    • Fai da te prima di porre la domanda
  • È facile caricare un'immagine, quindi caricare i grafici se si dispone
  • Includere anche eventuali errori che potresti avere

Tutti questi sono parte di un esempio riproducibile.


Oltre a tutte le risposte di cui sopra, che ho trovato molto interessanti, a volte potrebbe essere molto facile, come è discusso qui: - COME FARE UN ESEMPIO DI RIPRODUZIONE MINIMALE PER OTTENERE AIUTO CON R

Esistono molti modi per creare un vettore casuale Creare un vettore numerico a 100 con valori casuali in R arrotondato a 2 decimali o matrice casuale in R

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

Si noti che a volte è molto difficile condividere un dato dato a causa di vari motivi come dimensione ecc. Tuttavia, tutte le risposte di cui sopra sono grandiose e molto importanti da pensare e utilizzare quando si vuole fare un esempio di dati riproducibili. Si noti però che per rendere un dato così rappresentativo come l'originale (nel caso in cui l'OP non possa condividere i dati originali), è bene aggiungere alcune informazioni con l'esempio dei dati come (se chiamiamo i dati mydf1)

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

Inoltre, si dovrebbe conoscere il tipo, la lunghezza e gli attributi di un dato che possono essere strutture di dati

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

Puoi farlo usando github.com/tidyverse/reprex .

Come ha osservato mt1022 , "... un buon pacchetto per produrre un esempio minimo e riproducibile è " reprex " da tidyverse ".

Secondo Tidyverse :

L'obiettivo di "reprex" è di impacchettare il tuo codice problematico in modo che altre persone possano eseguirlo e sentire il tuo dolore.

Un esempio è dato sul sito web di tidyverse .

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

Penso che questo sia il modo più semplice per creare un esempio riproducibile.





r-faq