4

我有这个data.frame等长组（id）

id  |  amount 
--------------
 A  |   10   
 A  |   54   
 A  |   23   
 B  |   34   
 B  |   76    
 B  |   12

我想按组 id转置：

 id |
----------------------
 A  | 10  |  54 | 23  
 B  | 34  |  76 | 12

这样做最有效的方法是什么？

我以前用过reshape，dcast但它们确实很慢！（我有很多数据，很想加快这个瓶颈）

有更好的策略吗？使用data.table还是矩阵？？任何帮助将非常感激！

# Little data.frame
df <- data.frame(id=c(2,2,2,5,5,5), amount=as.integer(c(10,54,23,34,76,12)))

# Not so little data.frame
set.seed(10)
df <- data.frame(id = rep(sample(1:10000, 10000, replace=F),100), amount=as.integer(floor(runif(1000000, -100000,100000))))

# Create time variable
df$time <- ave(as.numeric(df$id), df$id, FUN = seq_along)

# The base R reshape strategy
system.time(df.reshape <-reshape(df, direction = "wide", idvar="id", timevar="time"))
user  system elapsed 
6.36    0.31    6.69 

# The reshape2 dcast strategy
require(reshape2)
a <- system.time(mm <- melt(df,id.vars=c('id','time'),measure.vars=c('amount')))
b <- system.time(df.dcast <- dcast(mm,id~variable+time,fun.aggregate=mean))
a+b
user  system elapsed 
14.44    0.00   14.45

更新 使用每个组长度相等的事实，您可以使用matrix-function。

df.matrix <- data.frame(id=unique(df$id), matrix(df$amount, nrow=(length(unique(df$id))), byrow=T))
user  system elapsed 
0.03    0.00    0.03

注意：此方法假定 data.frame 预先排序为id。

4

3 回答 3

2

矩阵方法将使用：

  system.time({ df.reshape <-matrix(df$amount, nrow=10000, byrow=TRUE); 
               rownames(df.reshape)<- df$id[1:10000]
             } )
   user  system elapsed 
  0.010   0.006   0.016
于 2013-01-31T14:28:15.787 回答
1

试试这个：

 dFrame<-data.frame(id = c(rep("A",3),rep("B",3)),amount = c(10,54,23,34,76,12))
 newFrame<-cbind(data.frame(id = unique(dFrame$id)),matrix(as.numeric(unlist(tapply(dFrame$amount,dFrame$id,identity))),nrow=length(unique(dFrame$id)),byrow=T))

括号可能已关闭，我已经尽量小心了 - 我目前没有可用的 R 解释器

基于您提供的 df 示例代码的基准测试结果：

  replications elapsed relative user.self sys.self user.child sys.child
   1            1   4.193        1     4.056    0.064          0         0
于 2013-01-31T14:04:50.300 回答
1

这不是问题reshape。aggregate从基地应该能够处理这个。

df.out <- aggregate(amount ~ id, data=df, c)
# running on the small data
#   id amount.1 amount.2 amount.3
# 1  2       10       54       23
# 2  5       34       76       12

这不是你想要的吗？

好的，似乎DWin's 解决方案的改编版本是最快的。但是，结果将按 排序id。如果您不想要那个，那么Aditya's 似乎是可以使用的。

以下是功能和基准测试结果：

  • 使用aggregate：

    AGG <- function() {
    df.agg <- aggregate(amount ~ id, data=df, c)
}

  • 使用Aditya_

    SEC <- function() {
    df.sec <- cbind(data.frame(id = unique(df$id)), 
            matrix(as.numeric(unlist(tapply(df$amount, df$id, identity))), 
            nrow = length(unique(df$id)), byrow = T))
}

  • 使用Dwin's 的修改版本：

    DWIN_M <- function() {
    df1 <- df[with(df, order(id)), ]
    idx <- df$id[!duplicated(df$id)]
    df.dwin <- cbind(data.frame(id=idx), 
                as.data.frame(matrix(df1$amount, 
                nrow=length(idx), byrow=TRUE)))
}

  • 基准测试：

    require(rbenchmark)
benchmark(AGG(), SEC(), DWIN_M(), replications=3, order="elapsed")

#      test replications elapsed relative user.self sys.self user.child sys.child
# 3 DWIN_M()            3   4.175    1.000     4.148    0.000          0         0
# 2    SEC()            3  17.568    4.208    17.449    0.016          0         0
# 1    AGG()            3  24.529    5.875    24.306    0.044          0         0

让我知道我是否犯了任何错误。

于 2013-01-31T14:24:04.143 回答