repositories - Cómo hacer un gran ejemplo reproducible de R

repositories r

Question

Cuando se analiza el rendimiento con colegas, se enseña, se envía un informe de error o se busca orientación sobre listas de correo y aquí en Stack Overflow, a menudo se solicita un ejemplo reproducible y siempre es útil.

¿Cuáles son tus consejos para crear un excelente ejemplo? ¿Cómo pegar las estructuras de datos de r en un formato de texto? ¿Qué otra información debe incluir?

¿Hay otros trucos además de usar dput() , dump() o structure() ? ¿Cuándo debe incluir la library() o require() declaraciones? ¿Qué palabras reservadas deben evitarse, además de c , df , data , etc.?

¿Cómo se hace un gran ejemplo reproducible?

Answer 1

Pautas:

Su objetivo principal en la elaboración de sus preguntas debe ser que sea lo más fácil posible para que los lectores entiendan y reproduzcan su problema en sus sistemas. Para hacerlo:

1. Proporcionar datos de entrada
2. Proporcionar salida esperada
3. Explica tu problema sucintamente
   • Si tiene más de 20 líneas de texto + código, probablemente pueda regresar y simplificar.
   • simplifique su código tanto como sea posible mientras preserva el problema / error

Esto requiere algo de trabajo, pero parece una compensación justa ya que le está pidiendo a otros que trabajen para usted.

Proporcionar datos:

Conjuntos de datos incorporados

La mejor opción, con mucho, es confiar en conjuntos de datos incorporados. Esto hace que sea muy fácil para otros trabajar en su problema. Escriba data() en el indicador de R para ver qué datos están disponibles para usted. Algunos ejemplos clásicos:

• iris
• mtcars
• ggplot2::diamonds (paquete externo, pero casi todos lo tienen)

Consulte este SO QA para saber cómo encontrar conjuntos de datos adecuados para su problema.

Si puede reformular su problema para usar los conjuntos de datos integrados, es mucho más probable que obtenga buenas respuestas (y votos positivos).

Datos autogenerados

Si su problema es muy específico para un tipo de datos que no están representados en los conjuntos de datos existentes, proporcione el código R que genera el conjunto de datos más pequeño posible en el que se manifiesta su problema. Por ejemplo

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

Ahora alguien que intenta responder mi pregunta puede copiar / pegar esas dos líneas y comenzar a trabajar en el problema de inmediato.

dput

Como último recurso , puede usar el dput para transformar un objeto de datos en un código R (por ejemplo, dput(myData) ). Lo digo como un "último recurso" porque la salida de dput es a menudo bastante difícil de manejar, molesta copiar y pegar, y oculta el resto de su pregunta.

Proporcionar salida esperada:

Alguien dijo una vez:

Una imagen de la salida esperada vale 1000 palabras

- una persona muy sabia

Si puedes agregar algo como "esperaba obtener este resultado":

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

Según tu pregunta, es mucho más probable que las personas entiendan rápidamente lo que estás tratando de hacer. Si su resultado esperado es grande y difícil de manejar, entonces probablemente no haya pensado lo suficiente sobre cómo simplificar su problema (vea a continuación).

Explique su problema sucintamente

Lo más importante es simplificar su problema tanto como sea posible antes de hacer su pregunta. Reenmarcar el problema para que funcione con los conjuntos de datos integrados ayudará mucho en este sentido. A menudo, también encontrará que con solo pasar por el proceso de simplificación responderá a su propio problema.

Aquí hay algunos ejemplos de buenas preguntas:

• con un conjunto de datos incorporado
• con datos generados por el usuario

En ambos casos, es casi seguro que los problemas del usuario no son los simples ejemplos que proporcionan. Más bien, resumieron la naturaleza de su problema y lo aplicaron a un conjunto de datos simple para formular su pregunta.

¿Por qué otra respuesta a esta pregunta?

Esta respuesta se centra en lo que creo que es la mejor práctica: usar conjuntos de datos incorporados y proporcionar lo que espera como resultado en una forma mínima. Las respuestas más destacadas se centran en otros aspectos. No espero que esta respuesta alcance ninguna prominencia; esto está aquí únicamente para que pueda vincularlo en los comentarios a las preguntas de los principiantes.

Answer 2

(Aquí está mi consejo de Cómo escribir un ejemplo reproducible . He intentado que sea breve pero dulce)

Cómo escribir un ejemplo reproducible.

Es más probable que obtenga una buena ayuda con su problema de R si proporciona un ejemplo reproducible. Un ejemplo reproducible le permite a otra persona recrear su problema simplemente copiando y pegando el código R.

Hay cuatro cosas que debe incluir para que su ejemplo sea reproducible: paquetes, datos, código y una descripción de su entorno R necesarios.

• Los paquetes deben cargarse en la parte superior de la secuencia de comandos, de modo que sea fácil ver cuáles necesita el ejemplo.

• La forma más fácil de incluir datos en un correo electrónico o en una pregunta de desbordamiento de pila es usar dput() para generar el código R para recrearlo. Por ejemplo, para recrear el conjunto de datos mtcars en R, realizaría los siguientes pasos:

  1. Ejecutar dput(mtcars) en R
  2. Copia la salida
  3. En mi script reproducible, escriba mtcars <- luego pegar.

• Pase un poco de tiempo asegurándose de que su código sea ​​fácil de leer para otros:

  • asegúrese de que ha utilizado espacios y que los nombres de sus variables son concisos, pero informativos

  • Usa comentarios para indicar dónde está tu problema

  • haga su mejor esfuerzo para eliminar todo lo que no esté relacionado con el problema.
    Cuanto más corto sea el código, más fácil será entenderlo.

• Incluya la salida de sessionInfo() en un comentario en su código. Esto resume su entorno R y hace que sea fácil comprobar si está utilizando un paquete obsoleto.

Puede verificar que realmente ha hecho un ejemplo reproducible al iniciar una nueva sesión R y pegar su script en.

Antes de poner todo su código en un correo electrónico, considere ponerlo en Gist github . Le dará a su código un buen resaltado de sintaxis, y usted no tiene que preocuparse por que el sistema de correo electrónico lo estropee.

Answer 3

A menudo, necesita algunos datos para un ejemplo, sin embargo, no desea publicar sus datos exactos. Para usar algún data.frame existente en la biblioteca establecida, use el comando data para importarlo.

p.ej,

data(mtcars)

y luego hacer el problema

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

Answer 4

A veces, el problema realmente no se puede reproducir con un dato más pequeño, no importa cuánto lo intente, y no ocurre con los datos sintéticos (aunque es útil para mostrar cómo produjo conjuntos de datos sintéticos que no reproducen el problema, porque descarta algunas hipótesis).

• Puede ser necesario publicar los datos en la web en algún lugar y proporcionar una URL.
• Si los datos no se pueden divulgar al público en general, pero se pueden compartir en absoluto, es posible que pueda ofrecer enviarlos por correo electrónico a las partes interesadas (aunque esto reducirá la cantidad de personas que se molestarán en trabajar). en eso).
• Realmente no he visto esto hecho, porque las personas que no pueden divulgar sus datos son sensibles a la liberación de cualquier forma, pero parece plausible que, en algunos casos, aún se puedan publicar datos si se anonimara / codificara / corrompiera lo suficiente. de alguna manera.

Si no puede hacer nada de esto, entonces probablemente deba contratar un consultor para resolver su problema ...

edición : dos preguntas de SO útiles para la anonimización / codificación:

• ¿Cómo crear conjuntos de datos de ejemplo a partir de datos privados (reemplazando nombres y niveles de variables con marcadores de lugar no informativos)?
• Dado un conjunto de números aleatorios extraídos de una distribución univariada continua, encuentre la distribución

Answer 5

Aquí hay una buena guía:

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

Pero lo más importante es: solo asegúrese de hacer un pequeño fragmento de código que podamos ejecutar para ver cuál es el problema. Una función útil para esto es dput() , pero si tiene datos muy grandes, es posible que desee hacer un pequeño conjunto de datos de muestra o usar solo las primeras 10 líneas.

EDITAR:

También asegúrese de identificar dónde se encuentra el problema. El ejemplo no debe ser un script R completo con "En la línea 200 hay un error". Si usa las herramientas de depuración en R (Me encanta browser() ) y google, debería poder identificar realmente dónde está el problema y reproducir un ejemplo trivial en el que la misma cosa salga mal.

Answer 6

Desde R.2.14 (supongo) puede alimentar su representación de texto de datos directamente a 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
")

Answer 7

El código reproducible es clave para obtener ayuda. Sin embargo, hay muchos usuarios que pueden ser escépticos de pegar incluso una parte de sus datos. Por ejemplo, podrían estar trabajando con datos confidenciales o en un dato original recopilado para usar en un trabajo de investigación. Por cualquier motivo, pensé que sería bueno tener una función útil para "deformar" mis datos antes de pegarlos públicamente. La función de anonymize del paquete SciencesPo es muy tonta, pero para mí funciona muy bien con la función 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

Luego lo anonimato:

> 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

También es posible que desee muestrear pocas variables en lugar de los datos completos antes de aplicar el comando de anonimización y 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

Answer 8

Estoy desarrollando el paquete de wakefield para abordar esta necesidad de compartir rápidamente datos reproducibles, a veces el dput funciona bien para conjuntos de datos más pequeños, pero muchos de los problemas con los que nos enfrentamos son mucho más grandes, compartir un conjunto de datos tan grande a través del dput es práctico.

Acerca de:

wakefield permite al usuario compartir un código mínimo para reproducir datos. El usuario establece n (número de filas) y especifica cualquier número de funciones de variable preestablecidas (actualmente hay 70) que imitan a los datos reales (cosas como género, edad, ingresos, etc.)

Instalación:

Actualmente (2015-06-11), wakefield es un paquete de GitHub pero irá a CRAN eventualmente después de que se escriban las pruebas unitarias. Para instalar rápidamente, use:

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

Ejemplo:

Aquí hay un ejemplo:

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

Esto produce:

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

Answer 9

Inspirado en este mismo post, ahora uso una función muy útil.
reproduce(<mydata>) cuando necesito publicar en .

Instrucciones rápidas

Si myData es el nombre de su objeto para reproducir, ejecute lo siguiente en R:

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

Detalles:

Esta función es una envoltura inteligente para realizar la dput y hace lo siguiente:

• muestrea automáticamente un gran conjunto de datos (según el tamaño y la clase. El tamaño de la muestra se puede ajustar)
• crea una salida dput
• le permite especificar qué columnas exportar
• se agrega al frente objName <- ... para que se pueda copiar y pegar fácilmente, pero ...
• Si está trabajando en un mac, la salida se copia automáticamente al portapapeles, de modo que simplemente puede ejecutarla y pegarla en su pregunta.

La fuente está disponible aquí:

• Github - pubR / reproduce.R

Ejemplo:

# 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 es de aproximadamente 100 x 102. Quiero muestrear 10 filas y algunas columnas específicas

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

Da la siguiente salida:

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

Observe también que la totalidad de la salida está en una sola línea larga y agradable, no en un párrafo alto de líneas cortadas. Esto hace que sea más fácil de leer en las publicaciones de preguntas SO y también más fácil de copiar y pegar.

Actualización de octubre de 2013:

Ahora puede especificar cuántas líneas de salida de texto ocuparán (es decir, lo que pegará en ). Use el argumento lines.out=n para esto. Ejemplo:

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

Answer 10

La lista de correo de R-help tiene una guía de publicación que cubre preguntas y respuestas, incluido un ejemplo de generación de datos:

Ejemplos: a veces es útil proporcionar un pequeño ejemplo que alguien pueda ejecutar. Por ejemplo:

Si tengo una matriz x como sigue:

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

¿Cómo puedo convertirlo en un marco de datos con 8 filas y tres columnas denominadas ''fila'', ''col'' y ''valor'', que tienen los nombres de dimensión como los valores de ''fila'' y ''col'', como esto:

 > x.df
row col value
1 A x 1

...
(A lo que la respuesta podría ser:

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

)

La palabra pequeña es especialmente importante. Debe apuntar a un ejemplo reproducible mínimo , lo que significa que los datos y el código deben ser lo más simples posible para explicar el problema.

EDITAR: El código bonito es más fácil de leer que el código feo. Utilice una guía de estilo .

Answer 11

Las respuestas hasta ahora son obviamente buenas para la parte de reproducibilidad. Esto es simplemente para aclarar que un ejemplo reproducible no puede y no debe ser el único componente de una pregunta. No olvide explicar cómo quiere que se vea y los contornos de su problema, no solo cómo ha intentado llegar hasta allí. Código no es suficiente; Necesitas palabras también.

Aquí hay un ejemplo reproducible de lo que se debe evitar (extraído de un ejemplo real, los nombres han sido cambiados para proteger a los inocentes):

Los siguientes son datos de muestra y parte de la función con la que tengo problemas.

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

Cómo puedo conseguir esto ?

Answer 12

Me pregunto si un enlace http://old.r-fiddle.org/ podría ser una forma muy buena de compartir un problema. Recibe una ID única como y uno podría incluso pensar en incrustarla en SO.

Answer 13

Para crear rápidamente una dput de sus datos, solo puede copiar (una parte) de los datos en su portapapeles y ejecutar lo siguiente en R:

para datos en Excel:

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

para datos en un archivo txt:

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

Puede cambiar el sep en el último si es necesario. Esto solo funcionará si sus datos están en el portapapeles, por supuesto.

Answer 14

Personalmente, prefiero "uno" trazadores de líneas. Algo a lo largo de las líneas:

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 estructura de datos debe imitar la idea del problema del escritor y no la estructura exacta exacta. Realmente aprecio que las variables no sobrescriban mis propias variables o las funciones de god forbid (como df ).

Alternativamente, uno podría cortar algunas esquinas y apuntar a un conjunto de datos preexistentes, algo como:

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

No olvide mencionar cualquier paquete especial que pueda estar usando.

Si está intentando demostrar algo en objetos más grandes, puede intentar

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

Si está trabajando con datos espaciales a través del paquete raster , puede generar algunos datos aleatorios. Se pueden encontrar muchos ejemplos en la viñeta del paquete, pero aquí hay un pequeño 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)

Si necesita algún objeto espacial como se implementó en sp , puede obtener algunos conjuntos de datos a través de archivos externos (como el shapefile ESRI) en paquetes "espaciales" (consulte la vista espacial en Vistas de tareas).

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

Answer 15

Por favor, no pegue las salidas de su consola de esta manera:

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

No podemos copiarlo y pegarlo directamente.

Para hacer que las preguntas y las respuestas se puedan reproducir correctamente, intente eliminarlas +y >publicarlas #para obtener resultados y comentarios como este:

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

Una cosa más, si ha usado alguna función de cierto paquete, mencione esa biblioteca.

Answer 16

Si tiene un conjunto de datos grande que no se puede poner fácilmente en el script mediante dput() , publique sus datos en pastebin y cárguelos utilizando read.table :

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

Inspirado en @Henrik .

Answer 17

Si tiene una o más variables de factor en sus datos que desea reproducir con dput(head(mydata)) , considere agregar droplevels de droplevels de datos, de modo que los niveles de factores que no están presentes en el conjunto de datos minimizado sean no incluido en su salida de dput , para que el ejemplo sea mínimo :

dput(droplevels(head(mydata)))

Answer 18

Tengo una manera muy fácil y eficiente de hacer un ejemplo de R que no se ha mencionado anteriormente. Puedes definir tu estructura en primer lugar. Por ejemplo,

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

A continuación, puede introducir sus datos manualmente. Esto es eficiente para ejemplos más pequeños en lugar de grandes.

Answer 19

Un ejemplo reproducible mínimo consiste en los siguientes elementos:

• Un conjunto de datos mínimo, necesario para reproducir el error.
• el código mínimo ejecutable necesario para reproducir el error, que se puede ejecutar en el conjunto de datos dado.
• La información necesaria sobre los paquetes utilizados, la versión R y el sistema en que se ejecuta.
• en el caso de procesos aleatorios, una semilla (establecida por set.seed() ) para reproducibilidad

A menudo es útil observar los ejemplos en los archivos de ayuda de las funciones utilizadas. En general, todo el código dado allí cumple los requisitos de un ejemplo reproducible mínimo: se proporcionan datos, se proporciona código mínimo y todo es ejecutable.

Producir un conjunto de datos mínimo

Para la mayoría de los casos, esto se puede hacer fácilmente simplemente proporcionando un marco de vector / datos con algunos valores. O puede usar uno de los conjuntos de datos integrados, que se proporcionan con la mayoría de los paquetes.
Se puede ver una lista completa de conjuntos de datos incorporados con la library(help = "datasets") . Hay una breve descripción de cada conjunto de datos y se puede obtener más información, por ejemplo, con ?mtcars donde ''mtcars'' es uno de los conjuntos de datos de la lista. Otros paquetes pueden contener conjuntos de datos adicionales.

Hacer un vector es fácil. A veces es necesario agregarle algo de aleatoriedad, y hay una gran cantidad de funciones para hacer eso. sample() puede aleatorizar un vector, o dar un vector aleatorio con solo unos pocos valores. letters es un vector útil que contiene el alfabeto. Esto puede ser usado para hacer factores.

Algunos ejemplos :

• Valores aleatorios: x <- rnorm(10) para la distribución normal, x <- runif(10) para la distribución uniforme, ...
• una permutación de algunos valores: x <- sample(1:10) para el vector 1:10 en orden aleatorio.
• un factor aleatorio: x <- sample(letters[1:4], 20, replace = TRUE)

Para matrices, se puede usar matrix() , por ejemplo:

matrix(1:10, ncol = 2)

La creación de marcos de datos se puede hacer usando data.frame() . Se debe prestar atención a nombrar las entradas en el marco de datos, y no hacerlo demasiado complicado.

Un ejemplo :

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

Para algunas preguntas, se pueden necesitar formatos específicos. Para estos, se puede usar cualquiera de las funciones as.someType proporcionadas: as.factor , as.Date , as.xts , ... Estos en combinación con los trucos de marco de datos y / o vector.

Copia tus datos

Si tiene algunos datos que serían muy difíciles de construir con estos consejos, siempre puede crear un subconjunto de sus datos originales, por ejemplo, head() , subset() o los índices. Entonces use por ejemplo. dput() para darnos algo que se pueda poner en R de inmediato:

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

Si su marco de datos tiene un factor con muchos niveles, la salida de la dput puede ser difícil de manejar porque aún enumera todos los niveles de factor posibles, incluso si no están presentes en el subconjunto de sus datos. Para resolver este problema, puede utilizar la función droplevels() . Observe a continuación cómo las especies son un factor con un solo nivel:

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

Otra advertencia para el dput es que no funcionará para objetos de data.table con data.table o para tbl_df agrupado (clase grouped_df ) de dplyr . En estos casos, puede volver a convertir a un marco de datos normal antes de compartir, dput(as.data.frame(my_data)) .

En el peor de los casos, puede dar una representación de texto que se pueda leer utilizando el parámetro text de 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)

Produciendo código mínimo

Esta debería ser la parte fácil pero a menudo no lo es. Lo que no debes hacer, es:

• Añadir todo tipo de conversiones de datos. Asegúrese de que los datos proporcionados ya estén en el formato correcto (a menos que ese sea el problema, por supuesto)
• Copie y pegue toda una función / fragmento de código que dé un error. En primer lugar, intente localizar qué líneas producen exactamente el error. La mayoría de las veces, descubrirás cuál es el problema.

Lo que debes hacer, es:

• agregue qué paquetes se deben usar si usa alguno (usando library() )
• Si abre conexiones o crea archivos, agregue algún código para cerrarlos o eliminar los archivos (usando unlink() )
• Si cambia las opciones, asegúrese de que el código contenga una declaración para revertirlas a las originales. (por ejemplo, op <- par(mfrow=c(1,2)) ...some code... par(op) )
• pruebe a ejecutar su código en una sesión R nueva y vacía para asegurarse de que el código sea ejecutable. La gente debería poder copiar y pegar sus datos y su código en la consola y obtener exactamente lo mismo que usted.

Dar informacion extra

En la mayoría de los casos, solo la versión R y el sistema operativo serán suficientes. Cuando surgen conflictos con los paquetes, puede resultar útil proporcionar la salida de sessionInfo() . Cuando se habla de conexiones a otras aplicaciones (ya sea a través de ODBC o cualquier otra cosa), también se deben proporcionar números de versión para esas y, si es posible, también la información necesaria sobre la configuración.

Si está ejecutando R en R Studio con rstudioapi::versionInfo() puede ser útil informar su versión de RStudio.

Si tiene un problema con un paquete específico, le packageVersion("name of the package") que proporcione la versión del paquete dando el resultado de packageVersion("name of the package") .

Answer 20

Aquí están algunas de mis sugerencias:

• Trate de usar conjuntos de datos R por defecto
• Si tiene su propio conjunto de datos, inclúyalos con dput, para que otros puedan ayudarlo más fácilmente.
• No lo use a install.package()menos que sea realmente necesario, la gente entenderá si usted simplemente usa requireolibrary

• Intenta ser conciso,

  • Tener algún conjunto de datos
  • Trate de describir la salida que necesita de la manera más sencilla posible.
  • Hágalo usted mismo antes de hacer la pregunta.
• Es fácil cargar una imagen, así que carga las parcelas si tienes
• Incluya también cualquier error que pueda tener

Todo esto es parte de un ejemplo reproducible.

Answer 21

Aparte de todas las respuestas anteriores que me parecieron muy interesantes, a veces podría ser muy fácil, tal como se explica aquí: - CÓMO HACER UN EJEMPLO DE REPRODUCIBLE MÍNIMO PARA OBTENER AYUDA CON R

Hay muchas formas de hacer un vector aleatorio. Crear un vector de 100 números con valores aleatorios en R redondeado a 2 decimales o matriz aleatoria en R

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

Tenga en cuenta que a veces es muy difícil compartir una información dada debido a varias razones, como la dimensión, etc. Sin embargo, todas las respuestas anteriores son geniales y muy importantes para pensar y usar cuando se desea crear un ejemplo de información reproducible. Pero tenga en cuenta que para hacer un dato tan representativo como el original (en caso de que el OP no pueda compartir los datos originales), es bueno agregar alguna información con el ejemplo de datos como (si llamamos a los datos mydf1)

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

Además, uno debe saber el tipo, la longitud y los atributos de los datos que pueden ser estructuras de datos.

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

Answer 22

Es una buena idea usar las funciones del testthatpaquete para mostrar lo que espera que ocurra. Por lo tanto, otras personas pueden alterar su código hasta que se ejecute sin error. Esto facilita la carga de quienes desean ayudarlo, porque significa que no tienen que descodificar su descripción textual. Por ejemplo

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

es más claro que "Creo que x sería 1.23 para y igual o superior a 10, y 3.21 de lo contrario, pero no obtuve ninguno de los resultados". Incluso en este ejemplo tonto, creo que el código es más claro que las palabras. El uso le testthatpermite a su ayudante enfocarse en el código, lo que ahorra tiempo y les proporciona una manera de saber que han resuelto su problema antes de publicarlo.

Answer 23

Puedes hacer esto usando github.com/tidyverse/reprex .

Como mt1022 señaló , "... un buen paquete para producir un ejemplo mínimo y reproducible es " reprex " de tidyverse ".

Según Tidyverse :

El objetivo de "reprex" es empaquetar su código problemático de tal manera que otras personas puedan ejecutarlo y sentir su dolor.

Un ejemplo se da en el sitio web tidyverse .

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

Creo que esta es la forma más sencilla de crear un ejemplo reproducible.