【问题标题】:Most efficient/vectorization when using previous calculated value (rolling)使用先前计算值(滚动)时最有效/矢量化
【发布时间】:2012-12-15 01:20:34
【问题描述】:

在这些对话之后:

  1. Can I vectorize a calculation which depends on previous elements
  2. sapply? tapply? ddply? dataframe variable based on rolling index of previous values of another variable

我想测试一个更“真实”的案例研究。 我最近不得不将 SAS 代码迁移到 R 并将 kdb 代码迁移到 R 代码。我试图编译一个足够简单但更复杂的示例来优化。

让我们建立训练集

buildDF <- function(N){
    set.seed(123); dateTimes <- sort(as.POSIXct("2001-01-01 08:30:00") + floor(3600*runif(N)));
    set.seed(124); f <- floor(1+3*runif(N));
    set.seed(123); s <- floor(1+3*runif(N));
    return(data.frame(dateTime=dateTimes, f=f, s=s));
}

这是需要实现的

f1 <- function(DF){
    #init
    N <- nrow(DF);
    DF$num[1] = 1;

    for(i in 2:N){
        if(DF$f[i] == 2){
            DF$num[i] <- ifelse(DF$s[i-1] == DF$s[i],DF$num[i-1],1+DF$num[i-1]);        
        }else{ #meaning f in {1,3}
            if(DF$f[i-1] != 2){
                DF$num[i] = DF$num[i-1]; 
            }else{
                DF$num[i] = ifelse((DF$dateTime[i]-DF$dateTime[i-1])==0,DF$num[i-1],1+DF$num[i-1]);
            }
        }
    }
    return(DF)
}

这当然是可怕的。让我们把它矢量化一下:

f2 <- function(DF){
    N <- nrow(DF);
    DF$add <- 1; DF$ds <- c(NA,diff(DF$s)); DF$lf <- c(NA,DF$f[1:(N-1)]);
    DF$dt <- c(NA,diff(DF$dateTime));
    DF$add[DF$f == 2 & DF$ds == 0] <- 0;
    DF$add[DF$f == 2 & DF$ds != 0] <- 1;
    DF$add[DF$f != 2 & DF$lf != 2] <- 0;
    DF$add[DF$f != 2 & DF$lf == 2 & DF$dt==0] <- 0;
    DF$num <- cumsum(DF$add);
    return(DF);
}

并使用最有用的data.table

f3 <- function(DT){
    N <- nrow(DT);
    DT[,add:=1]; DT[,ds:=c(NA,diff(s))]; DT[,lf:=c(NA,f[1:(N-1)])];
    DT[,dt:=c(NA,diff(dateTime))];
    DT[f == 2 & ds == 0, add:=0];
    DT[f == 2 & ds != 0, add:=1];
    DT[f != 2 & lf != 2, add:=0];
    DT[f != 2 & lf == 2 & dt == 0, add:=0];
    DT[,num:=cumsum(add)];
    return(DT);
}

在 10K 数据帧上:

library(rbenchmark);
library(data.table);

N <- 1e4;
DF <- buildDF(N)
DT <- as.data.table(DF);#we can contruct the data.table as a data.frame so it's ok we don't count for this time.

#make sure everybody is equal
DF1 <- f1(DF) ; DF2 <- f2(DF); DT3 <- f3(DT);
identical(DF1$num,DF2$num,DT3$num) 
[1] TRUE

#let's benchmark
benchmark(f1(DF),f2(DF),f3(DT),columns=c("test", "replications", "elapsed",
+ "relative", "user.self", "sys.self"), order="relative",replications=1);
    test replications elapsed relative user.self sys.self
2 f2(DF)            1   0.010      1.0     0.012    0.000
3 f3(DT)            1   0.012      1.2     0.012    0.000
1 f1(DF)            1   9.085    908.5     8.980    0.072

好的,现在在一个更体面的 5M 行 data.frame 上

N <- 5e6;
DF <- buildDF(N)
DT <- as.data.table(DF);
benchmark(f2(DF),f3(DT),columns=c("test", "replications", "elapsed",       
+ "relative", "user.self", "sys.self"), order="relative",replications=1);
    test replications elapsed relative user.self sys.self
2 f3(DT)            1   2.843    1.000     2.092    0.624
1 f2(DF)            1  10.920    3.841     4.016    5.137

我们通过 data.table 获得了 5 倍的收益。

我想知道 Rcpp 或 zoo:::rollapply 是否可以在此获得很多收益。 我会很高兴有任何建议

【问题讨论】:

  • 如何在 ?data.table 中设置 roll=TRUE
  • 使用 Rcpp 将使您的循环更快 - 如您自己在问题中引用的第一个问题所示。那么为什么不试试这种方法呢? SO 充满了答案,展示了人们从使用 Rcpp 中获得的真实和切实的收益。
  • Dirk 我正在尝试编写 Rcpp 代码,但我不得不承认我很难找到示例(我安装了 RcppExamples,但对我来说它看起来是空的 :))
  • N &lt;- 1e2; DF &lt;- buildDF(N); DT &lt;- as.data.table(DF); DF1 &lt;- f1(DF); DF2 &lt;- f2(DF); DT3 &lt;- f3(DT); identical(DF1$num,DF2$num,DT3$num) 返回[1] FALSE
  • 您肯定不会很难找到任何个Rcpp示例吧?你订阅了 R-bloggers 的 RSS 源吗?那里有很多 Rcpp 文章,有 100 个包使用它。很难错过他们!鉴于您提出的其他好问题,您将需要同时使用 R 和 C,而 Rcpp 将值得学习。例如,查看它与 RStudio 的集成。

标签: r optimization data.table zoo rcpp


【解决方案1】:

简单的内联 Rcpp 版本:

library(Rcpp)
library(inline)

f4cxx <- cxxfunction(signature(input="data.frame"), plugin="Rcpp", body='
  Rcpp::DataFrame df(input);
  const int N = df.nrows();  

  Rcpp::NumericVector f = df["f"];
  Rcpp::NumericVector s = df["s"];
  Rcpp::NumericVector d = df["dateTime"]; // As far as we need only comparation
  Rcpp::NumericVector num(N);             // it is safe to convert Datetime to Numeric (faster) 

  num[0] = 1;
  for(int i=1; i<N; i++){
    bool cond1 = (f[i]==2) && (s[i]!=s[i-1]);
    bool cond2 = (f[i]!=2) && (f[i-1]==2) && (d[i]!=d[i-1]);
    num[i] = (cond1 || cond2)?1+num[i-1]:num[i-1];    
  }

  df["num"] = num;
  return df;                                // Returns list
  //return (Rcpp::as<Rcpp::DataFrame>(df)); // Returns data.frame (slower)
  ')

退房:

N<-1e4; df<-buildDF(N)
identical(f1(df)$num, f4cxx(df)$num)

[1] TRUE

基准测试:

N<-1e5; df<-buildDF(N); dt<-as.data.table(df)
benchmark(f2(df), f2j(df), f3(dt), f4cxx(df),
          columns=c("test", "replications", "elapsed", "relative", "user.self", "sys.self"),
          order="relative", replications=1);

       test replications elapsed relative user.self sys.self
4 f4cxx(df)            1   0.001        1     0.000        0
2   f2j(df)            1   0.037       37     0.040        0
3    f3(dt)            1   0.058       58     0.056        0
1    f2(df)            1   0.078       78     0.076        0

【讨论】:

  • 您能记下您使用的是哪个版本的 Rcpp 吗?此外,如果f4cxx 返回一个列表而其他返回一个data.frame,这并不是一个准确的比较。 Rcpp 函数在返回 data.frame 时仍然快 2-4 倍。
  • 不错!!非常感谢,我这里有一些东西要处理!谢谢,新年快乐
  • @JoshuaUlrich,最初我使用的是 0.10.1。在我更新到 0.10.2 之后,我获得了更快的速度。谢谢!
  • @JoshuaUlrich:是的,在基准测试时返回list 而不是data.frame 是肮脏的伎俩:) 目的是显示潜在的加速来源。
  • 问题是我们丢失了List::operator[]的属性,所以使数据框成为数据框的东西丢失了。
【解决方案2】:

使用 Rcpp(或“普通的旧 C API”,如果您想让 Dirk 挠头)将您的第一个函数转换为 C/C++ 很可能是最快的。 data.table 解决方案可能紧随其后。

这是一个基本的 R 解决方案,它比您的 f2 函数快得多,因为它避免了很多 data.frame 子集(非常慢)。这说明了为了使基本 R 代码快速运行而应该做什么/避免什么,但要以代码清晰度/可读性为代价。

f2j <- function(DF){
  N <- nrow(DF)
  f2  <- DF$f == 2
  ds0 <- diff(DF$s) == 0
  lf2 <- f2[-N]
  f2  <- f2[-1]
  dt3 <- diff(DF$dateTime) == 0
  cond <- logical(N)
  cond[-1] <- (f2 & ds0) | (!f2 & !lf2) | (!f2 & lf2 & dt3)
  DF$num <- cumsum(!cond)
  DF
}

【讨论】:

  • 然而,N&lt;-1e4; df&lt;-buildDF(N); identical(f1(df)$num, f2j(df)$num) 返回[1] FALSE
  • @redmode,如果真的需要,它只需要被强制转换为numericall.equal(f1(df)$num, f2j(df)$num) 返回 [1] TRUEidentical(f1(df)$num, as.numeric(f2j(df)$num)) 也是如此
  • @redmode:是的,我是故意这样做的,因为整数向量比数字向量快,而且这个函数不需要双精度。
猜你喜欢
  • 1970-01-01
  • 2016-04-01
  • 2021-07-11
  • 2020-12-25
  • 1970-01-01
  • 1970-01-01
  • 2018-06-26
  • 1970-01-01
  • 2017-05-11
相关资源
最近更新 更多