Pivote en data.table similar a la función de fusión de rehape

reshape

Question

He leído algunas referencias a problemas similares aquí en SO, pero aún no he podido encontrar una solución y me pregunto si hay alguna forma de hacer lo siguiente utilizando solo data.table.

Usaré un ejemplo simplificado, pero en la práctica, mi tabla de datos tiene> 1000 columnas similares a var1, var2, ... var1000, etc.

dt <- data.table(uid=c("a","b"), var1=c(1,2), var2=c(100,200))

Estoy buscando una solución que me permita obtener una salida similar a la función de fusión de remodelación:

> melt(dt, id=c("uid"))
uid variable value
1   a     var1     1
2   b     var1     2
3   a     var2   100
4   b     var2   200

Es decir, todas las columnas, excepto el uid, se enumeran en una sola columna con los valores correspondientes en una columna contigua. He intentado esto con una combinación de lista, etc., pero podría faltar algo que sea obvio.

Todos los uids en dt son únicos.

Gracias por adelantado.

Answer 1

Auto-promoción descarada

Es posible que desee probar melt_ desde mi paquete Kmisc . melt_ es esencialmente una reescritura de reshape2:::melt.data.frame con la mayor parte del trabajo reshape2:::melt.data.frame realizado en C, y evita la mayor cantidad de copias y coerciones de tipo posible para una implementación rápida.

Un ejemplo:

## devtools::install_github("Kmisc", "kevinushey")
library(Kmisc)
library(reshape2)
library(microbenchmark)
n <- 1E6
big_df <- data.frame( stringsAsFactors=FALSE,
  x=sample(letters, n, TRUE),
  y=sample(LETTERS, n, TRUE),
  za=rnorm(n),
  zb=rnorm(n),
  zc=rnorm(n)
)
all.equal(
  melt <- melt(big_df, id.vars=c(''x'', ''y'')),
  melt_ <- melt_(big_df, id.vars=c(''x'', ''y''))
)
## we don''t convert the ''variable'' column to factor by default
## if we do, we see they''re identical
melt_$variable <- factor(melt_$variable)
stopifnot( identical(melt, melt_) )
microbenchmark( times=5,
  melt=melt(big_df, id.vars=c(''x'', ''y'')),
  melt_=melt_(big_df, id.vars=c(''x'', ''y''))
)

me da

Unit: milliseconds
  expr       min        lq    median         uq       max neval
  melt 916.40436 931.60031 999.03877 1102.31090 1160.3598     5
 melt_  61.59921  78.08768  90.90615   94.52041  182.0879     5

Con un poco de suerte, esto será lo suficientemente rápido para sus datos.

Answer 2

Para una remodelación de data.table, intente lo siguiente:

dt[, list(variable = names(.SD), value = unlist(.SD, use.names = F)), by = uid]

El costo de la sintaxis vale la pena; ¡La función se ejecuta muy rápidamente!

Answer 3

stack general, la stack supera al melt .

Un acercamiento directo a este problema con la stack sería:

dt[, stack(.SD), by = "uid"]

Por supuesto, puedes especificar tus .SDcols si es necesario. Y luego, usa setnames() para cambiar los nombres a lo que quieras.

(Alerta de autopromoción)

Escribí algunas funciones y las puse en un paquete llamado "splitstackshape". Una de las funciones se llama Stacked() , y en la versión 1.2.0 del paquete "splitstackshape", debería funcionar muy rápido.

Es un poco diferente de solo apilar todas las columnas restantes en una data.table . Es más análogo a la reshape() de R de la base que a la melt() de "reshape2". Aquí hay un ejemplo de Stacked() en acción.

He creado una data.table de data.table decentemente grande para hacer esta prueba. Hay 50 columnas numéricas que queremos apilar, y 50 columnas de factores que queremos apilar. También he optimizado aún más la respuesta de @Andreas.

Los datos

set.seed(1)
m1 <- matrix(rnorm(10000*50), ncol = 50)
m2 <- matrix(sample(LETTERS, 10000*50, replace = TRUE), ncol = 50)
colnames(m1) <- paste("varA", sprintf("%02d", 1:50), sep = "_")
colnames(m2) <- paste("varB", sprintf("%02d", 1:50), sep = "_")
dt <- data.table(uid = 1:10000, m1, m2)

Las funciones para el benchmarking.

test1 <- function() Stacked(dt, "uid", c("varA", "varB"), "_")

## merged.stack
test2 <- function() merged.stack(dt, "uid", c("varA", "varB"), "_")

## unlist(..., use.names = TRUE) -- OPTIMIZED
test3 <- function() {
  list(cbind(dt[, "uid", with = FALSE], 
             dt[, list(variable = rep(names(.SD), each = nrow(dt)), 
                       value = unlist(.SD)), 
                .SDcols = 2:51]),
       cbind(dt[, "uid", with = FALSE], 
             dt[, list(variable = rep(names(.SD), each = nrow(dt)), 
                       value = unlist(.SD)), 
                .SDcols = 52:101]))
}

## unlist(..., use.names = FALSE) -- OPTIMIZED
test4 <- function() {
  list(cbind(dt[, "uid", with = FALSE], 
             dt[, list(variable = rep(names(.SD), each = nrow(dt)), 
                       value = unlist(.SD, use.names = FALSE)), 
                .SDcols = 2:51]),
       cbind(dt[, "uid", with = FALSE], 
             dt[, list(variable = rep(names(.SD), each = nrow(dt)), 
                       value = unlist(.SD, use.names = FALSE)), 
                .SDcols = 52:101]))
}

## Andreas''s current answer
test5 <- function() {
  list(dt[, list(variable = names(.SD), 
                 value = unlist(.SD, use.names = FALSE)),
          by = uid, .SDcols = 2:51],
       dt[, list(variable = names(.SD), 
                 value = unlist(.SD, use.names = FALSE)), 
          by = uid, .SDcols = 52:101])
}

Los resultados

library(microbenchmark)
microbenchmark(Stacked = test1(), merged.stack = test2(),
               unlist.namesT = test3(), unlist.namesF = test4(),
               AndreasAns = test5(), times = 3)
# Unit: milliseconds
#           expr        min         lq     median         uq        max neval
#        Stacked   391.3251   393.0976   394.8702   421.4185   447.9668     3
#   merged.stack   764.3071   769.6935   775.0799   867.2638   959.4477     3
#  unlist.namesT  1680.0610  1761.9701  1843.8791  1881.9722  1920.0653     3
#  unlist.namesF   215.0827   242.7748   270.4669   270.6944   270.9218     3
#     AndreasAns 16193.5084 16249.5797 16305.6510 16793.3832 17281.1154     3

^^ No estoy seguro de por qué la respuesta actual de Andreas es tan lenta aquí. La "optimización" que hice fue básicamente para unlist sin usar by , lo que marcó una gran diferencia en las columnas "varB" (factor).

El enfoque manual es aún más rápido que las funciones de "splitstackshape", pero estamos hablando de milisegundos, ¡y un código bastante compacto de una sola línea!

Salida de muestra

Para referencia, aquí es cómo se ve la salida de Stacked() . Es una list de data.table de datos "apiladas", un elemento de lista para cada variable apilada.

test1()
# $varA
#           uid .time_1       varA
#      1:     1      01 -0.6264538
#      2:     1      02 -0.8043316
#      3:     1      03  0.2353485
#      4:     1      04  0.6179223
#      5:     1      05 -0.2212571
#     ---                         
# 499996: 10000      46 -0.6859073
# 499997: 10000      47 -0.9763478
# 499998: 10000      48  0.6579464
# 499999: 10000      49  0.7741840
# 500000: 10000      50  0.5195232
# 
# $varB
#           uid .time_1 varB
#      1:     1      01    D
#      2:     1      02    A
#      3:     1      03    S
#      4:     1      04    L
#      5:     1      05    T
#     ---                   
# 499996: 10000      46    A
# 499997: 10000      47    W
# 499998: 10000      48    H
# 499999: 10000      49    U
# 500000: 10000      50    W

Y, aquí es cómo se merged.stack salida de merged.stack . Es similar a lo que obtendrías al usar reshape(..., direction = "long") desde la base R.

test2()
#           uid .time_1       varA varB
#      1:     1      01 -0.6264538    D
#      2:     1      02 -0.8043316    A
#      3:     1      03  0.2353485    S
#      4:     1      04  0.6179223    L
#      5:     1      05 -0.2212571    T
#     ---                              
# 499996: 10000      46 -0.6859073    A
# 499997: 10000      47 -0.9763478    W
# 499998: 10000      48  0.6579464    H
# 499999: 10000      49  0.7741840    U
# 500000: 10000      50  0.5195232    W