Data Munging es la técnica general de transformar datos de una forma inutilizable o errónea a una forma útil. Sin algunos grados de transferencia de datos (independientemente de si la realiza un usuario especializado o un sistema automatizado), los datos no pueden estar listos para el consumo posterior. Básicamente, el procedimiento de limpieza manual de los datos se conoce como manipulación de datos. En la Programación R , las siguientes formas están orientadas con el proceso de manipulación de datos:
- aplicar() Familia
- agregar()
- paquete dplyr
- paquete de capas
Uso de la familia apply() para la recopilación de datos
En la colección apply() de R, la función más básica es la función apply() . Aparte de eso, existen lapply() , sapply() y tapply() . La colección completa de apply() puede considerarse un sustituto de un bucle. Es el tipo de función más restrictivo. Debe realizarse sobre una array que contenga todos los elementos homogéneos. Si la función apply() se realiza utilizando un marco de datos o cualquier otro tipo de objeto, la función primero lo cambiará a una array y luego realizará su operación. Básicamente se utiliza para evitar el uso explícito de estructura o construcción de bucle.
Sintaxis:
aplicar (X, margen, función)
Parámetros:
x: un arreglo o array
margen: un valor entre 1 y 2 para decidir dónde aplicar la función [ 1- fila; 2- columna]
función: la función a aplicar
Ejemplo:
R
# Using apply() m <- matrix(C <- (1:10), nrow = 5, ncol = 6) m a_m <- apply(m, 2, sum) a_m
Producción:
[,1] [,2] [,3] [,4] [,5] [,6] [1,] 1 6 1 6 1 6 [2,] 2 7 2 7 2 7 [3,] 3 8 3 8 3 8 [4,] 4 9 4 9 4 9 [5,] 5 10 5 10 5 10 [1] 15 40 15 40 15 40
En el ejemplo anterior, estamos calculando la suma de los elementos por columnas. Por lo tanto, para un gran conjunto de datos, podemos producir fácilmente el resultado deseado.
La función lapply() se usa para realizar operaciones en una lista y devuelve una lista resultante del mismo tamaño que la lista de entrada. La ‘l’ en lapply() se refiere a listas. La función lapply() no necesita el parámetro de margen.
Sintaxis:
lapply(X, función)
Parámetros:
X: la lista o un vector o un objeto
func: la función a aplicar
Ejemplo:
R
# Using lapply()
movies <- c("SPIDERMAN", "BATMAN",
"AVENGERS", "FROZEN")
movies
movies_lower <- lapply(movies,
tolower)
str(movies_lower)
Producción:
[1] "SPIDERMAN" "BATMAN" "AVENGERS" "FROZEN" List of 4 $ : chr "spiderman" $ : chr "batman" $ : chr "avengers" $ : chr "frozen"
La función sapply() toma cualquier vector, objeto o lista y realiza la misma operación que la función lapply() . Ambos tienen la misma sintaxis.
La función tapply() se utiliza para calcular o medir la media, la mediana, el máximo, etc., o para realizar una función sobre todos y cada uno de los factores de la variable. Se usa eficientemente para crear un subconjunto de cualquier vector y luego aplicar o realizar cualquier función en ellos.
Sintaxis:
tapply(X, índice, función = NULL)
Parámetros:
X: un objeto o vector
index: una lista de factores
func: la función a aplicar
Ejemplo:
R
# Using tapply() data(iris) tapply(iris$Sepal.Width, iris$Species, median)
Producción:
setosa versicolor virginica 3.4 2.8 3.0
Usando el agregado() en Data Munging
En R, la función de agregado() se usa para combinar o agregar el marco de datos de entrada aplicando una función en cada columna de un marco de subdatos. Para realizar la agregación o aplicar la función de agregación() debemos incluir lo siguiente:
- Los datos de entrada que deseamos agregar
- La variable dentro de los datos que se utilizará para agrupar por
- La función o cálculo a aplicar
La función de agregado() siempre devolverá un marco de datos que contiene todos los valores únicos del marco de datos de entrada después de aplicar la función específica. Solo podemos aplicar una sola función dentro de una función agregada. Para incluir múltiples funciones dentro de la función de agregado() , necesitamos usar el paquete plyr .
Sintaxis:
agregado (fórmula, datos, función)
Parámetros:
fórmula: la(s) variable(s) del marco de datos de entrada en el que queremos aplicar funciones.
datos: los datos que queremos usar para agrupar por operación.
función: la función o cálculo a aplicar.
Ejemplo:
R
# R program to illustrate
# aggregate() function
assets <- data.frame(
asset.class = c("equity", "equity",
"equity", "option",
"option", "option",
"bond", "bond"),
rating = c("AAA", "A", "A",
"AAA", "BB", "BB",
"AAA", "A"),
counterparty.a = c(runif(3), rnorm(5)),
counterparty.b = c(runif(3), rnorm(5)),
counterparty.c = c(runif(3), rnorm(5)))
assets
exposures <- aggregate(
x = assets[c("counterparty.a",
"counterparty.b",
"counterparty.c")],
by = assets[c("asset.class", "rating")],
FUN = function(market.values){
sum(pmax(market.values, 0))
})
exposures
Producción:
asset.class rating counterparty.a counterparty.b counterparty.c 1 equity AAA 0.08250275 0.5474595 0.9966172 2 equity A 0.33931258 0.6442402 0.2348197 3 equity A 0.68078755 0.5962635 0.6126720 4 option AAA -0.47624689 -0.4622881 -1.2362731 5 option BB -0.78860284 0.3219559 -1.2847157 6 option BB -0.59461727 -0.2840014 -0.5739735 7 bond AAA 1.65090747 1.0918564 0.6179858 8 bond A -0.05402813 0.1602164 1.1098481 asset.class rating counterparty.a counterparty.b counterparty.c 1 bond A 0.00000000 0.1602164 1.1098481 2 equity A 1.02010013 1.2405038 0.8474916 3 bond AAA 1.65090747 1.0918564 0.6179858 4 equity AAA 0.08250275 0.5474595 0.9966172 5 option AAA 0.00000000 0.0000000 0.0000000 6 option BB 0.00000000 0.3219559 0.0000000
Podemos ver que en el ejemplo anterior, los valores del marco de datos de activos se agregaron en las columnas «asset.class» y «rating».
Uso del paquete plyr para la transferencia de datos
El paquete plyr se utiliza para dividir, aplicar y combinar datos. El plyr es un conjunto de herramientas que se pueden usar para dividir datos enormes o grandes para crear una pieza homogénea, luego aplicar una función en todas y cada una de las piezas y finalmente combinar todos los valores resultantes. Ya podemos realizar estas acciones en R, pero al usar plyr podemos hacerlo fácilmente ya que:
- Los nombres, argumentos y salidas son totalmente consistentes.
- Paralelismo conveniente
- Tanto la entrada como la salida involucran marcos de datos, arrays o listas.
- Para rastrear la ejecución prolongada o los programas en ejecución, proporciona una barra de progreso
- Mensajes de error informativos incorporados y recuperación de errores
- Etiquetas que se mantienen a través de todas las transformaciones.
Las dos funciones que vamos a discutir en esta sección son ddply() y llply() . Para cada subconjunto de un marco de datos dado, ddply() aplica una función y luego combina el resultado.
Sintaxis:
ddply(.data, .variables, .fun = NULL, …, .progress = “none”, .inform = FALSE,
.drop = VERDADERO, .parallel = FALSO, .paropts = NULL)
Parámetros:
datos: el marco de datos que se va a procesar
variable: la variable en base a la cual dividirá el marco de datos
fun: la función a aplicar
…: otros argumentos que se pasan a la diversión
progreso: nombre de la barra de progreso
informar: si producir algún mensaje de error informativo
drop: la combinación de variables que no está en el marco de datos de entrada debe conservarse o descartarse.
paralelo: si aplicar la función paralelo
paropts: lista de opciones extra o adicionales aprobadas
Ejemplo:
R
# Using ddply()
library(plyr)
dfx <- data.frame(
group = c(rep('A', 8),
rep('B', 15),
rep('C', 6)),
sex = sample(c("M", "F"),
size = 29,
replace = TRUE),
age = runif(n = 29,
min = 18,
max = 54)
)
ddply(dfx, .(group, sex), summarize,
mean = round(mean(age), 2),
sd = round(sd(age), 2))
Producción:
group sex mean sd 1 A F 41.00 9.19 2 A M 35.76 12.14 3 B F 34.75 11.70 4 B M 40.01 10.10 5 C F 25.13 10.37 6 C M 43.26 7.63
Ahora veremos cómo usar llply() para trabajar en la manipulación de datos. La función llply() se usa en cada elemento de las listas, donde les aplicamos una función, y la salida resultante combinada también es una lista.
Sintaxis:
llply(.data, .fun = NULL,
…, .progress = “none”, .inform = FALSE,
.parallel = FALSE, .paropts = NULL)
Ejemplo:
R
# Using llply() library(plyr) x <- list(a = 1:10, beta = exp(-3:3), logic = c(TRUE, FALSE, FALSE, TRUE)) llply(x, mean) llply(x, quantile, probs = 1:3 / 4)
Producción:
$a
[1] 5.5
$beta
[1] 4.535125
$logic
[1] 0.5
$a
25% 50% 75%
3.25 5.50 7.75
$beta
25% 50% 75%
0.2516074 1.0000000 5.0536690
$logic
25% 50% 75%
0.0 0.5 1.0
Usando el paquete dplyr para Data Munging
El paquete dplyr se puede considerar como una gramática de manipulación de datos que nos proporciona un conjunto consistente de verbos que nos ayudan a resolver algunos de los desafíos más comunes de la manipulación de datos:
- arregla() se usa para cambiar el orden de las filas.
- filter() se usa para seleccionar casos según su valor o según el valor.
- mutate() se usa para agregar nuevas variables que son funciones de variables ya existentes.
- select() se usa para elegir o seleccionar variables en función de sus nombres.
- resume() se usa para reducir múltiples valores a un solo resumen.
Hay muchas más funciones en dplyr . El dplyr utiliza un backend muy eficiente que conduce a un menor tiempo de espera para el cálculo. Es más eficiente que el paquete plyr .
Sintaxis:
organizar (.datos, …, .por_grupo = FALSO)
filtrar(.datos, …)
mutar(.datos, …)
seleccionar(.datos, …)
resume(X, by, fun, …, stat.name = deparse(substitute(X)),
tipo = c(“variable”,”array”), subconjunto = VERDADERO, keepcolnames = FALSO)
Ejemplo:
R
# Using dplyr package
# Import the library
library(dplyr)
# Using arrange()
starwars %>%
arrange(desc(mass))
# Using filter()
starwars %>%
filter(species == "Droid")
# Using mutate()
starwars %>%
mutate(name,
bmi = mass / ((height / 100) ^ 2)) %>%
select(name:mass, bmi)
# Using select()
starwars %>%
select(name, ends_with("color"))
# Using summarise()
starwars %>% group_by(species) %>%
summarise(n = n(),
mass = mean(mass, na.rm = TRUE)) %>%
filter(n > 1)
Producción:
> starwars %>% arrange(desc(mass))
# A tibble: 87 x 13
name height mass hair_color skin_color eye_color birth_year gender homeworld species films vehicles starships
<chr> <int> <dbl> <chr> <chr> <chr> <dbl> <chr> <chr> <chr> <lis> <list> <list>
1 Jabba D~ 175 1358 NA green-tan, ~ orange 600 hermap~ Nal Hutta Hutt <chr~ <chr [0~ <chr [0]>
2 Grievous 216 159 none brown, white green, ye~ NA male Kalee Kaleesh <chr~ <chr [1~ <chr [1]>
3 IG-88 200 140 none metal red 15 none NA Droid <chr~ <chr [0~ <chr [0]>
4 Darth V~ 202 136 none white yellow 41.9 male Tatooine Human <chr~ <chr [0~ <chr [1]>
5 Tarfful 234 136 brown brown blue NA male Kashyyyk Wookiee <chr~ <chr [0~ <chr [0]>
6 Owen La~ 178 120 brown, grey light blue 52 male Tatooine Human <chr~ <chr [0~ <chr [0]>
7 Bossk 190 113 none green red 53 male Trandosha Trando~ <chr~ <chr [0~ <chr [0]>
8 Chewbac~ 228 112 brown unknown blue 200 male Kashyyyk Wookiee <chr~ <chr [1~ <chr [2]>
9 Jek Ton~ 180 110 brown fair blue NA male Bestine ~ Human <chr~ <chr [0~ <chr [1]>
10 Dexter ~ 198 102 none brown yellow NA male Ojom Besali~ <chr~ <chr [0~ <chr [0]>
# ... with 77 more rows
> starwars %>% filter(species == "Droid")
# A tibble: 5 x 13
name height mass hair_color skin_color eye_color birth_year gender homeworld species films vehicles starships
<chr> <int> <dbl> <chr> <chr> <chr> <dbl> <chr> <chr> <chr> <list> <list> <list>
1 C-3PO 167 75 NA gold yellow 112 NA Tatooine Droid <chr [6]> <chr [0]> <chr [0]>
2 R2-D2 96 32 NA white, blue red 33 NA Naboo Droid <chr [7]> <chr [0]> <chr [0]>
3 R5-D4 97 32 NA white, red red NA NA Tatooine Droid <chr [1]> <chr [0]> <chr [0]>
4 IG-88 200 140 none metal red 15 none NA Droid <chr [1]> <chr [0]> <chr [0]>
5 BB8 NA NA none none black NA none NA Droid <chr [1]> <chr [0]> <chr [0]>
> starwars %>% mutate(name, bmi = mass / ((height / 100) ^ 2)) %>% select(name:mass, bmi)
# A tibble: 87 x 4
name height mass bmi
<chr> <int> <dbl> <dbl>
1 Luke Skywalker 172 77 26.0
2 C-3PO 167 75 26.9
3 R2-D2 96 32 34.7
4 Darth Vader 202 136 33.3
5 Leia Organa 150 49 21.8
6 Owen Lars 178 120 37.9
7 Beru Whitesun lars 165 75 27.5
8 R5-D4 97 32 34.0
9 Biggs Darklighter 183 84 25.1
10 Obi-Wan Kenobi 182 77 23.2
# ... with 77 more rows
> starwars %>% select(name, ends_with("color"))
# A tibble: 87 x 4
name hair_color skin_color eye_color
<chr> <chr> <chr> <chr>
1 Luke Skywalker blond fair blue
2 C-3PO NA gold yellow
3 R2-D2 NA white, blue red
4 Darth Vader none white yellow
5 Leia Organa brown light brown
6 Owen Lars brown, grey light blue
7 Beru Whitesun lars brown light blue
8 R5-D4 NA white, red red
9 Biggs Darklighter black light brown
10 Obi-Wan Kenobi auburn, white fair blue-gray
# ... with 77 more rows
> starwars %>% group_by(species) %>%
+ summarise(n = n(),mass = mean(mass, na.rm = TRUE)) %>%
+ filter(n > 1)
# A tibble: 9 x 3
species n mass
<chr> <int> <dbl>
1 Droid 5 69.8
2 Gungan 3 74
3 Human 35 82.8
4 Kaminoan 2 88
5 Mirialan 2 53.1
6 Twi'lek 2 55
7 Wookiee 2 124
8 Zabrak 2 80
9 NA 5 48