-
Notifications
You must be signed in to change notification settings - Fork 0
/
002-toolkit-ciencia-datos.qmd
961 lines (563 loc) · 34.2 KB
/
002-toolkit-ciencia-datos.qmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
# **R** toolkit para la ciencia de datos {#toolkit}
:::{.callout-warning}
### Objetivos {-}
- Instalar el software **R** y su IDE (Entorno de Desarrollo Integrado) **RStudio**.
- Informes reproducibles con **`quarto`** y control de versiones con **`GitHub`**.
- Conocer los fundamentos del modelo **CRISP-DM**.
:::
## R y RStudio
### Instalación de R y RStudio {#instal-r-rstudio}
**R** es un entorno de software libre para la computación estadística y
los gráficos. Se compila y ejecuta en una amplia variedad de plataformas
UNIX, Windows y MacOS. Las fuentes, los binarios y la documentación de R
pueden obtenerse a través de CRAN[^rstudio-1]. Para descargar **R** elija
su espejo CRAN preferido en
[www.r-project.org](https://www.r-project.org/).
[^rstudio-1]: La "Comprehensive R Archive Network" (CRAN) es una
colección de sitios que contienen material idéntico, consistente en
la(s) distribución(es) de R, las extensiones aportadas, la
documentación para R y los binarios. El sitio principal de CRAN en
la WU (Wirtschaftsuniversität Wien) en Austria puede encontrarse en
la URL <https://CRAN.R-project.org/> y se refleja diariamente en
muchos sitios de todo el mundo.
**RStudio** es un entorno de desarrollo integrado (IDE) para **R**. Incluye
una consola, un editor que resalta la sintaxis y admite la ejecución
directa del código, así como herramientas para el trazado, el historial,
la depuración y la gestión del espacio de trabajo. RStudio está disponible en ediciones comerciales y de código abierto y
se ejecuta en el escritorio (Windows, Mac y Linux) o en un navegador
conectado a RStudio Server o RStudio Workbench (Debian/Ubuntu, Red
Hat/CentOS y SUSE Linux), está disponible en
[www.rstudio.com](https://www.rstudio.com/).
:::{.callout-note}
El orden es importante:
1. Instale **R**.
2. Instale **RStudio**.
:::
Compruebe que tiene instalados los iconos de la @fig-002-panrstudio2 y abra RStudio.
```{r , echo=FALSE, out.width='60%', fig.align='center', fig.cap='Iconos de R y RStudio'}
#| label: fig-002-panrstudio2
knitr::include_graphics("img/02-open-rstudio.png")
```
### Interfaz de RStudio
Al abrir el programa se observan cuatro paneles (véase @fig-002-panrstudio).
- **Sripts**: para escribir código.
- **Consola**: contiene la Consola, Terminal y los Jobs.
- **Entorno**: contiene el *Environment*, *History*, *conexiones* y *Git*, entre otros.
- **Files, Plots, Packages, Help y Viewer**
La posición de los paneles se puede personalizar al gusto del
usuario, al igual que la apariencia del IDE.
```{r , echo=FALSE, out.width='80%', fig.align='center', fig.cap='Paneles de RStudio'}
#| label: fig-002-panrstudio
knitr::include_graphics(here::here("img/02-rstudio-layout.png"))
```
:::{.callout-note}
La posición relativa y el contenido de cada panel pueden personalizarse
desde el menú: Tools \> Global Options \> Pane Layout
:::
### Instalación los paquetes
Los paquetes son adiciones modulares al software **R** que añaden
funcionalidad en forma de nuevas funciones, conjuntos de datos,
documentación, etc. El repositorio estándar de paquetes **R** es
"Comprehensive R Archive Network" (CRAN).
:::{.callout-note}
[**CRAN Task Views**](https://cran.r-project.org/web/views/):
Ofrecen un breve resumen de los paquetes incluidos.
:::
Los paquetes se instalan con la función base de **R** `install.packages()`:
```{r , eval=FALSE}
install.packages("tidyverse")
```
:::{.callout-note}
Los paquetes se instalan una única vez y se leen cada vez que se utilizan.
:::
Alternativamente, se pueden instalar desde el panel de Paquetes en RStudio desde una interfaz gráfica.
### Proyectos
Ser organizado desde el principio es uno de los mejores hábitos y en **R** esto se consigue trabajando con proyectos.
Un proyecto de **R** agrupa todo los ficheros del trabajo en una carpeta de forma que
se facilita su manejo, el trabajo colaborativo y su reproducibilidad.
:::{.callout-note}
*Crear un proyecto Quarto en R:*
Desde el menú: File \> New Project y luego elija:
- `Nuevo Directorio`
- `Proyecto Vacío`
- Elija un nombre para el directorio, por ejemplo, `mi_proyecto`
- Haga clic en `Crear Proyecto`.
:::
- `r emo::ji("folder")` **data**: para los datos.
- `r emo::ji("folder")` **img**: para las imágenes.
- `r emo::ji("folder")` **src**: contiene los *scripts* de **R** para llevar a cabo las
distintas tareas del análisis.
- `r emo::ji("folder")` **output**: se guardarán los resultados
finales de nuestro análisis.
- **README.md** debe contener
la información básica sobre el proyecto, la compatibilidad, los *inputs*
que necesita, los *outputs* que genera y un resumen de flujo del trabajo.
Ésto ayudará a cualquiera a comprender mejor cómo es nuestro proyecto.
Una de las estructuras más comunes es la mostrada en la @fig-proyecto:
```{r , echo=FALSE, fig.align='center'}
#| label: fig-proyecto
#| fig-cap: Ejemplo de estructura de un proyecto en R.
knitr::include_graphics(here::here("img/02-estructura_proyecto.png"))
```
:::{.callout-note}
Los distintos scripts se pueden ejecutar desde otros scripts.
Para ello se utiliza la función `source()`
:::
### Trabajar con un *script* de R
Para comenzar a escribir un *script* nuevo nos dirigimos a File \> New
File. Los más utilizados actualmente son:
+ `r emo::ji("notebook")` \> R Script.
+ `r emo::ji("book")` \> Quarto document.
+ `r emo::ji("notebook")` \> R Notebook.
+ `r emo::ji("document")` \> R Markdown.
:::{.callout-note}
Si se tiene creado un proyecto Quarto mejor trabajar con un un `quarto document` para luego renderizar todo el documento.
Véase @wickham2016r para un estudio profundo de proyectos.
:::
El editor es un editor de texto plano (sin negritas ni cursivas) pero
ofrece un código de colores del texto dependiendo de lo que se escriba
(resaltado de sintaxis).
Es extremadamente útil comentar el *script* con
información adicional para hacer más claro el proceso de programación. Para añadir un
comentario, simplemente hay que poner `#` al comienzo de la linea y lo
que esté a la derecha no será ejecutado.
Finalmente, a la hora de escribir código en **R** lo más conveniente es usar las
buenas prácticas diseñadas por programadores expertos. Para ello, lo
mejor es aplicar una guía de estilo `r emo::ji("book")`, cuyo objetivo es hacer que nuestro
código **R** sea más fácil de leer, compartir y verificar. Una de las
mejores guías es [The tidyverse style
guide](https://style.tidyverse.org/index.html).
## El ecosistema `tidyverse` {#tidy}
```{r tidy-logo, echo=FALSE, out.width='20%'}
knitr::include_graphics(here::here("img/02-logo-tityverse.png"))
```
El [tidyverse](https://www.tidyverse.org/) es una colección de **paquetes de R para la ciencia de los datos**. Todos los paquetes comparten una filosofía de diseño, una gramática y unas estructuras de datos subyacentes. Se basan en la idea *tidy* data propuesta por Hadley Wickham (Wickham et al. 2014) y pueden instalarse con una única orden en **R**:
```{r , eval=FALSE}
install.packages("tidyverse")
```
Una vez instalado, se cargan con la función `library`:
```{r , message=FALSE, warning=FALSE}
library(tidyverse)
```
Los paquétes más importantes en ciencia de datos se enumeran a continuación.
```{r readr-logo, echo=FALSE, out.width='15%', fig.align='left'}
knitr::include_graphics(here::here("img/02-logo-readr.png"))
```
### `readr`
El paquete `readr` roporciona una forma rápida y amigable de leer datos
rectangulares (como csv, tsv y fwf). Está diseñado para
analizar de forma flexible muchos tipos de datos que se encuentran en la naturaleza, mientras que sigue fallando limpiamente cuando los datos cambian inesperadamente.
`readr` admite los siguientes formatos de archivo asociados a estas funciones `read_*()`:
- **`read_csv()`**: valores separados por coma, ficheros (CSV).
- **`read_tsv()`**: valores separados por tabulador, fichero (TSV).
- **`read_delim()`**: fichro delimitados (CSV y TSV son casos especiales).
- **`read_fwf()`**: archivos de ancho fijo.
- **`read_table()`**: archivos separados por espacios en blanco
- **`read_log()`**: archivos de logos web.
:::{.callout-exm}
Lea la base de datos de calidad del aire de la ciudad de Madrid , `dt_daily_mean_2011.RDS`,
contenida en la carpeta `data`.
:::
(TODO): QUITAR LA FUNCIÓN HERE PORQUE A ESTE NIVEL SI NO SE EXPLICA PUEDE LIAR
```{r}
air_mad <- readr::read_rds("data/dt_daily_mean_2011.RDS")
```
```{r dplyr-logo, echo=FALSE, out.width='15%', fig.align='left'}
knitr::include_graphics(here::here("img/02-logo-dplyr.png"))
```
### `dplyr`
El paquete [`dplyr`](https://dplyr.tidyverse.org/articles/dplyr.html)
Ofrece una gramática de la manipulación de datos, proporcionando
un conjunto coherente de verbos que resuelven los problemas
más comunes de manipulación de datos y que pueden ser organizado
tres categorías basado en el dataset:
1. **Filas:**
- **`filter()`**: elige filas en función de los valores de la columna.
- **`slice()`**: elige filas en función de la ubicación.
- **`arrange()`**: cambia el orden de las filas.
2. **Columnas:**
- **`select()`**: indica cuando una columa es incluida o no.
- **`rename()`**: cambia el nombre de la columna.
- **`mutate()`**: cambia los valores de las columnas y crea nuevas columnas.
- **`relocate()`**: cambia el orden de las columnas.
3. **Grupos de filas:**
- **`summarise()`**: contrae un grupo en una sola fila.
:::{.callout-note}
### El operador pipe {-}
Canaliza la salida de una función a la entrada de otra función.
```{r eval=FALSE}
segundo(primero(datos))
```
se traduce en:
```{r eval=FALSE}
datos %>%
primero %>%
segundo
```
**Operador pipe de \{maggrit\}** `%>%`
**Operador pipe de R base** `|>`
:::
:::{.callout-tip}
### Ejemplo. Medidas de posición por estación de monitoreo
Calcule las medidas de posición (mínimo, máximo, Q1, Q3, media y mediana)
por estación de monitoreo , agrupando
por `id_name` para Partículas \< 2.5 µm `nom_abv == "PM2.5"` utilizando las funciones de la libreria `dplyr`.
:::
```{r}
air_mad %>% # Summary por grupo usando dplyr
na.omit() %>% # omitimos los NAs para el análisis
filter(nom_abv == "PM2.5") %>% # filtramos por PM2.5
group_by(id_name) %>%
summarize(min = min(daily_mean),
q1 = quantile(daily_mean, 0.25),
median = median(daily_mean),
mean = mean(daily_mean),
q3 = quantile(daily_mean, 0.75),
max = max(daily_mean))
```
```{r tidyr-logo, echo=FALSE, out.width='15%', fig.align='left'}
knitr::include_graphics(here::here("img/02-logo-tidyr.png"))
```
### `tidyr`
El paquete `tidyr` proporciona un conjunto de funciones que le ayudan a
obtener datos ordenados. Los datos ordenados son datos con una forma consistente. En resumen, cada variable va en una columna, y cada columna es una variable.
Las funciones se agrupan en 5 grandes categorías:
1. **Pivotar**. Convierte entre formas largas y anchas, `pivot_longer()` y `pivot_wider()`
2. **Rectangling**. Convierte listas profundamente anidadas (a partir de JSON) en `tibbles` ordenados: `unnest_longer()`, `unnest_wider()`, `hoist()`.
3. **Anidar**. Convierte los datos agrupados en una forma en el que cada grupo se convierte en una sola fila que contiene un data frame anidado `nest()` y viceversa, `unnest()`.
4. **Dividir y combinar columnas de caracteres**. Funciones: `separate()`, `extract()` y `unite()`
5. **Valores perdidos**. Funciones: `complete()`, `drop_na()`, `fill()`, `replace_na()`
:::{.callout-tip}
### Ejemplo. ¿Cuál es el día con mayor y menor concentración de NOx de todo el periodo?
:::
```{r}
air_mad %>% # Summary por grupo usando dplyr
na.omit() %>% # omitimos los NAs para el análisis
filter(nom_abv == "NOx") %>% # filtramos por NOx
group_by(fecha) %>% # agrupamos por fecha
summarize(mad_mean = mean(daily_mean)) %>% # promedio de las estaciones
slice(which.max(mad_mean), which.min(mad_mean)) #seleccionamos el máximo y el mínimo
```
El valor máximo, **415 µg/m3 de NOx**, se observa el 21 de diciembre de 2011 y el valor mínimo, **6,32 µg/m3 de NOx**, el 10 de mayo de 2020, en pleno estado de alarma.
```{r ggplot2-logo, echo=FALSE, out.width='15%', fig.align='left'}
knitr::include_graphics(here::here("img/02-logo-ggplot2.png"))
```
### `ggplot2`
El paquete `ggplot2` es un sistema para crear gráficos de forma ordenada,
basado en *The Grammar of Graphics*. Al proporcionar los datos,
le dice a ggplot2 cómo asignar a las variables la estética y
qué gráficas utilizar.
El template básico para la función `ggplot()` es:
```{r , eval=FALSE}
ggplot(data = <DATA>) +
<GEOM_FUNCTION>(mapping = aes(<MAPPINGS>))
```
Los argumentos más importantes para la representación de gráficos son:
* `ggplot()`, crea un nuevo gráfico.
* `aes()`, construye la estética el gráfico.
* `+(<gg>)`, añade componentes al gráfico.
* `ggsave()`, guarda el gráfico.
:::{.callout-tip}
### Ejemplo. Gráfico de violín.
Represente, con un gráfico de violín, las concentraciones de NOx por año en
el periodo estudiado.
:::
Una buena forma de ver los datos es por medio de un gráfico de violín:
```{r, message=FALSE}
air_mad %>% # Summary por grupo usando dplyr
na.omit() %>% # omitimos los NAs para el análisis
filter(nom_abv == "NOx") %>% # filtramos por NOx
group_by(year = format(fecha, "%Y")) %>%
summarise(daily_mean) %>%
ggplot(aes(factor(year), daily_mean))+
geom_violin() +
geom_jitter(height = 0, width = 0.01) +
aes(x=factor(year), y=daily_mean, fill=year)
```
:::{.callout-note}
Libro de referencia obligatoria: [**ggplot2: elegant graphics for data analysis**](https://ggplot2-book.org/index.html).
Es interesante conocer las [**Extensiones de ggplot2**](https://exts.ggplot2.tidyverse.org/gallery/)
así como las [**ggplot2 Cheat sheet**](https://github.com/rstudio/cheatsheets/blob/main/data-visualization-2.1.pdf) disponible.
:::
```{r purrr-logo, echo=FALSE, out.width='15%', fig.align='left'}
knitr::include_graphics(here::here("img/02-logo-purrr.png"))
```
### `purrr`
El paquete `purrr` mejora el conjunto de herramientas de programación
funcional (PF) de R proporcionando un conjunto completo y coherente de herramientas para
trabajar con funciones y vectores. Una vez que se dominan los conceptos básicos, `purrr`
permite sustituir muchos bucles `for` por un código más fácil de escribir
y más expresivo.
:::{.callout-note}
Consulte la [**purrr Cheat sheet**](https://github.com/rstudio/cheatsheets/blob/main/purrr.pdf) disponible para una descripcion de la librería.
:::
```{r tibble-logo, echo=FALSE, out.width='15%', fig.align='left'}
knitr::include_graphics(here::here("img/02-logo-tibble.png"))
```
### `tibble`
El paquete `tibble` es una reimaginación moderna del marco de datos,
manteniendo lo que el tiempo ha demostrado que es eficaz, y desechando
lo que no. Los Tibbles suelen conducir a un código más limpio y expresivo.
:::{.callout-tip}
Consulte el capítulo 10 de [**R for data science**](https://es.r4ds.hadley.nz/tibbles.html) disponible
online para una primera aproximación.
:::
```{r stringr-logo, echo=FALSE, out.width='10%', fig.align='left'}
knitr::include_graphics(here::here("img/02-logo-stringr.png"))
```
### `stringr`
El paquete `stringr` proporciona un conjunto cohesivo de funciones diseñadas
para facilitar al máximo el trabajo con cadenas.
:::{.callout-tip}
Consulte el capítulo 14 de [**R for data science**](https://es.r4ds.hadley.nz/cadenas-de-caracteres.html) disponible
online para una primera aproximación.
:::
```{r forcats-logo, echo=FALSE, out.width='15%'}
knitr::include_graphics(here::here("img/02-logo-forcats.png"))
```
### `forcats`
El paquete `forcats` proporciona un conjunto de herramientas útiles que resuelven problemas comunes con los factores. R utiliza factores para manejar variables categóricas, variables que tienen un conjunto fijo y conocido de valores posibles.
:::{.callout-note}
Consulte el capítulo 14 de [**R for data science**](https://es.r4ds.hadley.nz/factores.html) disponible online para una primera aproximación.
:::
## Informes reproducibles con Quarto/Rmarkdown {#quarto}
Este es un documento **R Quarto**. Quarto es una sintaxis simple de formato para la creación de documentos HTML, PDF y MS Word. Para obtener más detalles sobre cómo usar R Quarto consulta <https://quarto.org/>.
RMarkdown (el antecesor de Quarto) y Quarto son herramientas permiten combinar texto formateado con código y resultados en un mismo documento. Quarto facilita la interoperabilidad entre **R**, **Python**, **Julia**.
Los documentos Quarto constan principalmetne de 3 partes:
+ el YAML (o cabecera del documento),
+ el texto (cuerpo escrito del documento),
+ las chunks (tozos de código, en este caso, código **R**)
A continuación se exponen, brevemente, las principales ideas para entender y trabajar sintaxis `quarto`.
### Introducción
#### Markdown: un lenguaje de marcado ligero
Markdown es un lenguaje de marcado ligero y fácil de aprender que permite dar formato al texto de manera sencilla. Con *Markdown*, es posible aplicar negrita, cursiva, encabezados, listas y enlaces, entre otras opciones de formato, simplemente utilizando una sintaxis intuitiva. La facilidad de uso del lenguaje *Markdown* hace que sea ampliamente utilizado, sobre todo para la documentación.
#### Integración de código y resultados
Una de las características principales de Quarto/Rmarkdown es la capacidad de integrar código en el informe. Esto significa que se pueden incluir bloques de código o *chunks* en lenguajes como R, Python o Julia directamente en el documento. Estos bloques de código se ejecutan en tiempo real y los resultados, como tablas o gráficos, se incrustan automáticamente en el informe. Esto permite a los lectores ver tanto el código como los resultados generados, lo que promueve la transparencia y la reproducibilidad.
#### Generación de múltiples formatos de salida
Quarto ofrece la posibilidad de generar informes en diferentes formatos de salida, como por ejemplo: HTML, PDF, Word o presentaciones de diapositivas. Esto es especialmente útil cuando se necesita compartir el informe con diferentes audiencias o cuando se requiere una presentación visualmente atractiva. La conversión entre formatos se realiza de manera automática y se puede personalizar para que se adapte a las necesidades específicas de cada proyecto.
#### Facilidad de uso y colaboración
Quarto se integra con RStudio, lo que proporciona una experiencia de usuario fluida y amigable. Además, los archivos Rmarkdown son archivos de texto plano, lo que hace que sean fáciles para el control de versiones como Git. Esto facilita el trabajo en equipo y la colaboración en proyectos.
:::{.callout-tip}
La mayoría de los paquetes tiene una amplia documentación y los llamados *Cheatsheets* (chuletas). Son un buen método para ampliar los conocimientos. Algunas de ellas son:
- Documentación de [Quarto](https://quarto.org/docs/authoring/markdown-basics.html#callout-blocks)
- *Cheatsheet* de [RMarkdown](https://www.rstudio.com/wp-content/uploads/2015/02/rmarkdown-cheatsheet.pdf)
- Colección de otros *cheatsheets* de [RStudio](https://posit.co/resources/cheatsheets/)
:::
### Instalación
Para poder utilizar Quarto/Rmarkdown en R y RStudio, es necesario realizar algunos pasos de instalación. A continuación, se detallan los pasos necesarios:
1. Instalar R (véase @instal-r-rstudio).
2. Instalar RStudio (véase @instal-r-rstudio).
3. Intalar Quarto: para ello hay que dirigirse a la página oficial de [Quarto](https://quarto.org/), acceder al apartado [Get Started](https://quarto.org/docs/get-started/) y seleccionar la instalación acorde al sistema operativo. POsteriormente hay que seguir los pasos del instalador.
4. Instalar el paquete Quarto: Una vez que R, RStudio y Quarto, se debe instalar la librería de Quarto para habilitar la funcionalidad de Quarto en R y RStudio. Para ello, se puede ejecutar el siguiente comando en la consola de RStudio:
`install.packages("quarto")`
Después de la instalación, se debe configurar RStudio para utilizar Quarto como el motor de renderizado de Rmarkdown. Para ello, se debe abrir la pestaña *Tools* (Herramientas) en la barra de menú de RStudio y seleccionar *Global Options* (Opciones globales). En la ventana emergente, selecciona la pestaña *R Markdown* y asegúrate de que la opción *Quarto* esté seleccionada en la sección *Render*.
Con estos pasos completados, ya se puede comenzar a utilizar Quarto en RStudio para crear informes reproducibles. Se puede crear un nuevo archivo Rmarkdown y comenzar a combinar texto y código en un solo documento.
### El YAML
La sintaxis básica de YAML utiliza pares clave-valor en el formato `clave: valor`. Otros campos YAML comúnmente encontrados en los encabezados de los documentos incluyen metadatos como `author` (autor), `subtitle` (subtítulo), `date` (fecha), así como opciones de personalización como `theme` (tema), `fontcolor` (color de la fuente), `fig-width` (ancho de la figura), etc. Se puede encontrar información sobre todos los campos YAML disponibles para documentos HTML en la página oficial de [Quarto](https://quarto.org/docs/reference/formats/html.html). Los campos YAML disponibles varían según el formato del documento, por ejemplo,los campos YAML para documentos [PDF](https://quarto.org/docs/reference/formats/pdf.html) y para [MS Word](https://quarto.org/docs/reference/formats/docx.html).
````
---
title: "My Document"
author:
- Gema Fernández-Avilés
- Michal Kinel
format:
html:
toc: true
code-fold: true
---
````
### Flujo de trabajo y el concepto renderizar
Un informe en Quarto/Rmarkdown se compone de bloques de texto y bloques de código. El texto se escribe en formato Markdown. Los bloques de código, *chunks* se delimitan con etiquetas especiales y pueden contener código en R, Python u otros lenguajes compatibles.
:::{.callout-note}
**renderizar** en RMarkdown/Quarto se refiere al proceso de transformar un documento escrito en lenguaje Markdown, que combina texto y código, en un formato final legible y presentable, como un informe, un documento PDF o una página web interactiva.
El proceso de renderizado se realiza mediante la ejecución de un motor de renderizado, como Quarto, que interpreta el documento RMarkdown y produce el resultado final en el formato deseado, como un archivo HTML, PDF, Word, entre otros. Durante el proceso de renderizado, el motor ejecuta el código R, genera los gráficos y tablas correspondientes, y aplica el formato y estilo definidos en el documento.
:::
La mejor manera de tejer un `html_document` es mediante el botón `Render` o la función `quarto::quarto_render()`.
```{r rmark-0, echo=FALSE, out.width='60%', fig.align='center', fig.cap='Diagrama de transformación de un documento Quarto a HTML, PDF, etc.'}
knitr::include_graphics(here::here("img/02-quarto.png"))
```
#### Trozos de código *chunks*
Los bloques de código en Quarto/Rmarkdown se utilizan para incorporar código fuente en el informe. Estos bloques se delimitan mediante etiquetas especiales, como `{r}` para código en R o `{python}` para código en Python. Dentro de estos bloques, se puede escribir y ejecutar código de la misma manera que se haría en un entorno de programación normal.
La ejecución del código se realiza en tiempo real, lo que significa que los resultados generados, como tablas, gráficos o textos formateados, se incrustan directamente en el informe cuando se renderiza. Esto permite a los lectores ver los resultados obtenidos y verificar la reproducibilidad del análisis.
Se puede insertar rápidamente bloques de código con el comando Agregar Bloque en la barra de herramientas del editor o escribiendo los delimitadores de bloque:
```{r}
2+2
```
La salida de una chunk se puede personalizar con las opciones de knitr. Algunas de las más usadas son:
- `|# include: false` evita que el código y los resultados aparezcan en el archivo final. R Markdown sigue ejecutando el código en el chunk, y los resultados pueden ser utilizados por otros chunks.
- `|# echo : false` evita que el código, pero no los resultados, aparezcan en el archivo final. Es una forma útil de incrustar cifras.
- `|# message : false` evita que los mensajes generados por el código aparezcan en el archivo final.
- `|# warning : false` evita que las advertencias generadas por el código aparezcan en el acabado.
- `|# fig.cap : "..."` añade una leyenda a los resultados gráficos.
Más información sobre la opción de trozos de código: [Quarto chunks](https://quarto.org/docs/reference/cells/cells-knitr.html).
#### Formato de texto
El texto en formato Markdown se utiliza para proporcionar explicaciones, descripciones y contexto en el documento Escribir texto en Markdown es sencillo, ya que no requiere conocimientos avanzados de programación. Con Markdown, se pueden aplicar diferentes estilos de formato utilizando una sintaxis sencilla y legible.
Se pueden añadir [enlaces](www.r-graph-gallery.com), escribir en **negrita** o *cursiva*. Consulta la hoja de trucos de Rstudio [descargar aquí](https://raw.githubusercontent.com/rstudio/cheatsheets/main/rmarkdown.pdf).
> Hacer citas
| bloque de línea
**Otros formatos de texto:**
- [subrayado]{.underline}
- ~~tachar~~
- ^superíndice^
- ~subíndice~
- [versalitas]{.smallcaps}
La forma de añadir notas a pie de página es `[^number]`[^1]
[^1]: la nota a pie de página
También se puede añadir emojis increíbles como 😻 insertándolo en el editor visual markdown o mediante su código `:heart_eyes_cat:`.
------------------------------------------------------------------------
A veces es necesario separar el texto con una línea horizontal, para ello simplemente se introduce `***`
<br><br><br><br>
o saltar una línea con código html `<br><br><br><br>`.
#### Añadir una imagen
Para añadir imágenes basta con escribir `![image_name](image_path)`
![R learners. Créditos: Allison Horst](img/02-Rlearners.png)
Si desea centrar la imagen, un poco de código htm le ayudará, sólo tiene que utilizar `<center> </center>`
<center>
![R & RStudio](https://bookdown.org/oscar_teach/estadistica_aplicada_con_r/r-rstudio.png)
</center>
Para ajustar las imágenes puedes usar **r chunk** añadiendo la imagen con una función `knitr::include_graphics`
```{r, fig.align='right', out.width='20%', fig.cap='Mi super foto'}
knitr::include_graphics("https://bookdown.org/oscar_teach/estadistica_aplicada_con_r/r-rstudio.png")
```
```{r}
#| label: fig-plots
#| fig-cap: "Plots"
#| layout-ncol: 2
#| fig-subcap:
#| - "Plot 1: eed and Stopping Distances of Cars"
#| - "Plot 2: por Pressure of Mercury as a Function of Temperature"
plot(cars)
plot(pressure)
```
Véanse ejemplos en @fig-plots. En particular, @fig-plots-2.
#### Ecuaciones
Insertar ecuaciones en un documento Quarteo es fácil utilizando la escritura Latex
+ en línea: $A = (\pi * \lambda \times r^{4}) / \alpha$
+ centradas: $$A = (\pi * \lambda \times r^{4}) / \alpha$$
#### Diagramas
Quarto tiene soporte nativo para incrustar diagramas [Mermaid](https://mermaid-js.github.io/mermaid/#/) y [Graphviz](https://graphviz.org/). Esto te permite crear diagramas de flujo, diagramas de secuencia, diagramas de estado, diagramas gnatt, y más usando una sintaxis de texto plano inspirada en markdown.
Por ejemplo, aquí se incrusta un diagrama de flujo creado con Mermaid:
```{mermaid}
flowchart LR
A[Hard edge] --> B(Round edge)
B --> C{Decision}
C --> D[Result one]
C --> E[Result two]
```
Gantt diagram:
```{mermaid}
gantt
dateFormat YYYY-MM-DD
title Adding GANTT diagram to mermaid
excludes weekdays 2014-01-10
section A section
Completed task :done, des1, 2014-01-06,2014-01-08
Active task :active, des2, 2014-01-09, 3d
Future task : des3, after des2, 5d
Future task2 : des4, after des3, 5d
```
#### Bloques de llamada
:::{.callout-note}
Tenga en cuenta que hay cinco tipos de llamadas, incluyendo:
`note`, `tip`, `warning`, `caution`, and `important`.
:::
#### Listas
::: {layout-ncol=2}
- ítem X
- ítem Y
- ítem Z
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur gravida eu erat et fring. Morbi congue augue vel eros ullamcorper, eget convallis tortor sagittis. Fusce sodales viverra mauris a fringilla. Donec feugiat, justo eu blandit placerat, enim dui volutpat turpis, eu dictum lectus urna eu urna. Mauris sed massa ornare, interdum ipsum a, semper massa.
:::
#### Apéndice {.appendix}
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
#### Citaciones
R Markdown The Definitive Guide [@xie2018r]
### Renderizado
Utiliza el botón de **Render** en el entorno de desarrollo integrado (IDE) de RStudio para renderizar el archivo y previsualizar el resultado con un solo clic o combinación de teclas (⇧⌘K).
```{r, fig.align='center'}
knitr::include_graphics("img/rstudio-render.png")
```
Si se prefiere renderizar automáticamente cada vez que se guarda el documento, se puede activar la opción de Renderizar al Guardar (Render on Save) en la barra de herramientas del editor. La previsualización se actualizará cada vez que vuelvas a renderizar el documento. La vista de previsualización en paralelo funciona tanto para salidas en HTML como en PDF.
## Buscar ayuda en **R** o sobre **R** (funciones, paquetes, errores)
Las funciones de distintos paquetes de R tienen su ayuda y es muy fácil
acceder a ella desde la consola poniendo un signo de interrogación
delante de la función, por ejemplo al ejecutar `?mean` en la consola se
abrirá la ventana de ***Help*** con la descripción de la función, su
uso, los argumentos y otros datos relevantes que nos permitirán entender
mejor la función que ejecutamos. También, existe una amplia información
online sobre las funciones y distintos paquetes disponible en
[Rdocumentation.org](https://rdocumentation.org/).
### Haz preguntas
Uno de los foros más amplio de búsqueda de preguntas y respuestas sobre
la programación es
[StackOverflow](https://stackoverflow.com/questions/tagged/r). En
StackOverflow se registraron hasta el momento más 450.000 preguntas. Se
puede navegar por los archivos de StackOverflow y ver qué respuestas han
sido votadas por los usuarios, o puedes hacer tus propias preguntas
relacionadas con R y esperar una respuesta.
<!-- ::: infobox -->
<!-- **Cómo crear un ejemplo mínimo y reproducible** -->
<!-- Cuando se hace una pregunta, la gente será más capaz de proporcionar ayuda si se -->
<!-- proporciona un código que puedan entender fácilmente y utilizar para -->
<!-- reproducir el problema. Los miembros de la comunidad se refieren a esto -->
<!-- como la creación de un ejemplo mínimo y reproducible (reprex), un -->
<!-- ejemplo mínimo, completo y verificable (mcve), o un ejemplo mínimo y -->
<!-- viable (mwe). Independientemente de cómo se le comunique, se reduce a -->
<!-- asegurar que su código que reproduce el problema sigue las siguientes -->
<!-- directrices: -->
<!-- Tus ejemplos de código deben ser... -->
<!-- - Mínimos - Utilizar la menor cantidad de código posible que siga -->
<!-- produciendo el mismo problema -->
<!-- - Completos - Proporcionar todas las partes que alguien necesita para -->
<!-- reproducir su problema en la propia pregunta -->
<!-- - Reproducible - Pruebe el código que va a proporcionar para -->
<!-- asegurarse de que reproduce el problema -->
<!-- ::: -->
<!-- Si tienes una pregunta más relacionada con la metodología estadística, -->
<!-- también hay muchos usuarios de R activos en la comunidad de preguntas y -->
<!-- respuestas de [CrossValidated](https://stats.stackexchange.com/). -->
<!-- Además se puede pedir ayuda a los usuarios de R y RStudio en -->
<!-- [community.rstudio.com](https://community.rstudio.com/). -->
### Sigue la comunidad de R
Existen diversas páginas web que contienen artículos sobre la
programación en R, como por ejemplo:
- [R bloggers](https://www.r-bloggers.com/): un agregador de blogs que
vuelve a publicar artículos relacionados con R de toda la web. Un
buen lugar para encontrar tutoriales de R,
- [RWeekly](https://rweekly.org/): R Weekly se fundó el 20 de mayo
de 2016. R está creciendo muy rápidamente, y hay un montón de
grandes blogs, tutoriales y otros formatos de recursos que salen
cada día. R Weekly quiere hacer un seguimiento de estas grandes
cosas en la comunidad de R y hacerla más accesible para todos.
- [RPubs](https://rpubs.com/): RStudio permite aprovechar el poder de
R Markdown para crear documentos que entrelazan su escritura y la
salida de su código R. En RPubs se puede publicar esos documentos en
la web en un click.
- [Medium](https://medium.com/): un sitio web de blogs donde se puede
encontrar mucha temática sobre el Data Science.
## Git y GitHub
¿Git y GitHub? En primer lugar, son dos cosas distintas:
- **Git** es un software de código abierto para el control de
versiones. Con Git puedes hacer cosas como ver todas las versiones
anteriores del código que has creado en un proyecto.
- **GitHub** es el servicio más popular (otros son GitLab y BitBucket)
para colaborar en el código utilizando Git.
### ¿Por qué debería usar Git y GitHub?
Las tres principales ventajas de utilizar Git y GitHub son:
1. El uso de Git y GitHub sirve como copia de seguridad. Dado que
GitHub tiene una copia de todo el código que tienes localmente, si
algo le ocurriera a tu ordenador, seguirías teniendo acceso a tu
código.
2. El uso de Git y GitHub te permite utilizar el control de versiones.
¿Alguna vez has tenido documentos llamados trabajo_final.pdf,
trabajo_final_2.pdf o este_es_el_final.pdf? En lugar de hacer copias
de los archivos por miedo a perder el trabajo, el control de
versiones permite ver lo que se hizo en el pasado, todo ello
manteniendo versiones únicas de los documentos.
3. El uso de Git y GitHub hace posible trabajar en el mismo proyecto al
mismo tiempo con distintos colaboradores. Se puede ver el autor de
los cambios y se fuera necesario volver a la versión anterior.
Para poner Git y GitHub a punto lo mejor es seguir la guía de [Happy Git
and GitHub for the useR](https://happygitwithr.com/) en la que se
explica paso a paso como registrarse en GitHub e instalar Git, además de
integrarlo en RStuidio.