【问题标题】:Fast function to add vector elements by their names按名称添加矢量元素的快速函数
【发布时间】:2013-04-02 13:44:17
【问题描述】:

我写了这个 R 函数,给定任意数量的向量 (...),通过根据它们的名称对各自的元素值求和来组合它们。

add_vectors <- function(...) {
  a <- list(...)
  nms <- sort(unique(unlist(lapply(a, names))))
  out <- numeric(length(nms))
  names(out) <- nms
  for (v in a) out[names(v)] <- out[names(v)] + v

  out
}

例子:

v1 <- c(a=2,b=3,e=4)
v2 <- c(b=1,c=6,d=0,a=4)
add_vectors(v1, v2)
#
a b c d e 
6 4 6 0 4

我正在尝试编写一个快得多的等效函数。

不幸的是,目前我不知道如何在R 中实现这一点,所以我想到了Rcpp。 但是,为了在Rcpp 中转换这个函数,我错过了一些概念:

  1. 如何管理... 参数。使用List 参数输入Rcpp ?
  2. 如何迭代...参数中的向量。
  3. 如何通过名称访问(然后求和)向量的元素(这在R 中非常简单,但我不知道如何在Rcpp 中进行操作)。

所以我正在寻找可以帮助我提高此功能的性能的人(R 或Rcpp,或两者兼有)。

感谢您的帮助。

【问题讨论】:

  • 你的向量有多大?这还不够快吗? tapply(c(v1, v2), factor(c(names(v1), names(v2)), levels=union(names(v1), names(v2))), sum)
  • 或者这个:unlist(lapply(split(c(v1,v2), names(c(v1,v2))), sum))。虽然我怀疑第一个在大向量上会比使用split 更快。
  • @Arun:感谢您的解决方案,我已经对短向量进行了基准测试,您的解决方案大约慢了 2-3 倍(可能大向量的结果会反转)。

标签: performance r vector rcpp


【解决方案1】:

我会使用这样的东西:

#include <Rcpp.h>
using namespace Rcpp; 

// [[Rcpp::export]]
NumericVector add_all(List vectors){
    RCPP_UNORDERED_MAP<std::string,double> out ; 
    int n = vectors.size() ;
    for( int i=0; i<n; i++){
        NumericVector x = vectors[i] ;
        CharacterVector names = x.attr("names") ;
        int m = x.size() ;

        for( int j=0; j<m; j++){
            String name = names[j] ;
            out[ name ] += x[j] ;   
        }
    }
    return wrap(out) ;
}

使用以下包装器:

add_vectors_cpp <- function(...){
    add_all( list(...) )
}

RCPP_UNORDERED_MAP 只是 unordered_map 的 typedef,在 std:: 或 std::tr1:: 中取决于您的编译器等...

这里的技巧是使用经典的list(...) 从... 创建一个常规列表。

如果你真的想在 C++ 中直接传递... 并在内部处理它,你将不得不使用.External 接口。这很少使用,所以 Rcpp 属性不支持.External 接口。

使用.External,它看起来像这样(未经测试):

SEXP add_vectors(SEXP args){
    RCPP_UNORDERED_MAP<std::string,double> out ; 
    args = CDR(args) ;
    while( args != R_NilValue ){
        NumericVector x = CAR(args) ;

        CharacterVector names = x.attr("names") ;
        int m = x.size() ;

        for( int j=0; j<m; j++){
            String name = names[j] ;
            out[ name ] += x[j] ;   
        }        
        args = CDR(args) ;
    }   
    return wrap(out) ;
}

【讨论】:

  • 非常感谢@Romain Francois 提供更简洁(更完整)的解决方案。也感谢您对... 参数和CDR 函数的澄清。
  • 使用list(...) 将创建所有输入的副本,这可能是要付出沉重的性能代价。一种更复杂的方法(但不需要 .External)是传递函数环境和未计算的参数名称。
  • 好收获。也许值得在Rcpp::export 属性中支持.External 接口
【解决方案2】:

使用 compiler 包编译成字节码会给你一些改进。此软件包随 R.

library(compiler)
library(microbenchmark)

add_vectors_cmp <- cmpfun(add_vectors)

set.seed(1)
v <- rpois(length(letters), 10)
names(v) <- letters
vs <- replicate(150, v, simplify=FALSE)

not_compiled <- function(l) do.call(add_vectors, l)
compiled <- function(l) do.call(add_vectors_cmp, l)

plot(microbenchmark(not_compiled(vs), compiled(vs)))

【讨论】:

  • 我知道compiler 包和相关的,但这不是我要找的。不管怎样,谢谢! =)
【解决方案3】:

data.table 包非常擅长执行聚合和其他操作。我不是真正的专家,但是

library(data.table)
add_vectors5 <- function(...)
{
    vals <- do.call(c, list(...))
    dt <- data.table(nm=names(vals), v=vals, key="nm")
    dt <- dt[,sum(v), by=nm]
    setNames(dt[[2]], dt[[1]])
}

似乎比其他纯 R 实现快约 2 倍。一个更神秘的实现是

add_vectors6 <- function(..., method="radix")
{
    vals <- do.call(c, list(...))
    ## order by name, but use integers for faster order algo
    idx <- match(names(vals), unique(names(vals)))
    o <- sort.list(idx, method=method, na.last=NA)

    ## cummulative sum of ordered values
    csum <- cumsum(vals[o])

    ## subset where ordering factor changes, and then diff
    idxo <- idx[o]
    diff(c(0, csum[idxo != c(idxo[-1], TRUE)]))
}

容易出现数值溢出;如果名称少于 100,000 个,则使用 method="radix",如 ?sort.list 所暗示的那样,否则使用 method="quick"。

【讨论】:

    【解决方案4】:

    我刚刚在Rcpp 中写了这个函数的二进制版本(2 个输入)。

    我不知道如何在Rcpp 中使用... 参数(以及如何对其进行迭代),所以我将此函数封装在一个简单的R 函数中。

    解决方案

    library(Rcpp)
    cppFunction(
      code = '
      NumericVector add_vectors_cpp(NumericVector v1, NumericVector v2) {
        // merging names, sorting them and removing duplicates
        std::vector<std::string> nms1 = v1.names();
        std::vector<std::string> nms2 = v2.names();
        std::vector<std::string> nms;
        nms.resize(nms1.size() + nms2.size());
        std::merge(nms1.begin(), nms1.end(), nms2.begin(), nms2.end(), nms.begin());
        std::sort(nms.begin(), nms.end());
        nms.erase(std::unique(nms.begin(), nms.end()), nms.end());
        // summing vector elements by their names and storing them in an associative data structure
        int num_names = nms.size();
        std::tr1::unordered_map<std::string, double> map(num_names);
        for (std::vector<int>::size_type i1 = 0; i1 != nms1.size(); i1++) {
            map[nms1[i1]] += v1[i1];
        }
        for (std::vector<int>::size_type i2 = 0; i2 != nms2.size(); i2++) {
            map[nms2[i2]] += v2[i2];
        }
        // extracting map values (to use as result vector) and keys (to use as result vector names)
        NumericVector vals(map.size());
        for (unsigned r = 0; r < num_names; ++r) {
            vals[r] = map[nms[r]];
        }
        vals.names() = nms;
        return vals;
      }',
      includes = '
      #include <vector>
      #include <tr1/unordered_map>
      #include <algorithm>'
    )
    

    然后封装在一个R函数中:

    add_vectors_2 <- function(...) {
      Reduce(function(x, y) add_vectors_cpp(x, y), list(...))
    }
    

    请注意,此解决方案使用 STL 库。 我不知道这是否是一个编写良好的 C++ 解决方案,或者是否可以(可能)编写一个更有效的解决方案,但可以肯定它是一个好的(并且有效的)起点。

    使用示例

    v1 <- c(b = 1, d = 2, c = 3, a = 4, e = 6, f = 5)
    v2 <- c(d = 2, c = 3, a = 4, e = 6, f = 5)
    add_vectors(v1, v2, v1, v2)
    #  a  b  c  d  e  f 
    # 16  2 12  8 24 20
    add_vectors_2(v1, v2, v1, v2)
    #  a  b  c  d  e  f 
    # 16  2 12  8 24 20 
    

    注意:此函数也适用于名称不唯一的向量。

    v1 <- c(b = 1, d = 2, c = 3, a = 4, e = 6, f = 5)
    v2 <- c(d = 2, c = 3, a = 4, e = 6, f = 5, f = 10, a = 12)
    add_vectors(v1, v2)
    #  a  b  c  d  e  f 
    # 16  1  6  4 12 15 
    add_vectors_2(v1, v2)
    #  a  b  c  d  e  f 
    # 20  1  6  4 12 20
    

    如上一个示例所示,即使输入向量具有不唯一的名称,该解决方案也能工作,将具有相同名称的同一向量的元素相加。

    基准

    在最简单的情况下(两个向量),我的解决方案比 R 解决方案快大约 3 倍。这是一个很好的改进,但可能还有更好的C++ 解决方案进一步小的改进空间。

    Unit: microseconds
                     expr    min     lq median      uq     max neval
      add_vectors(v1, v2) 65.460 68.569 70.913 73.5205 614.274   100
    add_vectors_2(v1, v2) 20.743 23.389 25.142 26.9920 337.544   100
    

    将此函数应用于更多向量时,性能会有所下降(仅快 2 倍)。

    Unit: microseconds
                                     expr     min       lq  median       uq     max neval
      add_vectors(v1, v2, v1, v2, v1, v1) 105.994 195.7565 205.174 212.5745 993.756   100
    add_vectors_2(v1, v2, v1, v2, v1, v1)  66.168 125.2110 135.060 139.7725 666.975   100
    

    所以现在的最后一个目标是删除直接使用Rcpp 管理...(或类似,例如List)参数的R wrapping 函数。

    我认为这是可能的,因为Rcppsugar 具有与其相似的功能(例如sapply 函数的移植),但希望得到一些反馈。

    【讨论】:

      【解决方案5】:

      我不认为你会得到太多的加速。我在 R 代码中采用了另一种方法,将所有输入组合成一个向量,然后按名称重新拆分,并与 vapply 聚合。那里的所有函数或多或少都调用内部 C 代码,并且速度与大型向量的函数相当(在长度为 1e5 和 1e6 的向量上测试)。对于 3 或 4 个元素的玩具示例,它会慢一些。

      add_vectors2 <- function(...) {
        y <- do.call(c, unname(list(...)))
        vapply(split(y, names(y)), sum, numeric(1))
      }
      
      #Longer sample vectors
      m <- 1e3
      n <- 1e6
      v1 <- sample(m, n, replace = TRUE)
      names(v1) <- sample(n)
      v2 <- sample(m, n, replace = TRUE)
      names(v2) <- sample(seq_len(n) + n / 2)  
      
      #Timings
      k <- 20
      system.time(for(i in 1:k) add_vectors(v1, v2))   #5 or 6 seconds
      system.time(for(i in 1:k) add_vectors2(v1, v2))  #same
      

      编辑:矢量名称固定为唯一,反映了 Roland 的评论。我的解决方案现在比 OP 慢一点。

      【讨论】:

      • OP 的函数假设每个向量的名称都是唯一的,而您的则不是。因此,大型向量的结果会有所不同。
      • @Roland:名称必须唯一这一事实不是主要要求,而是速度。 ;)
      猜你喜欢
      • 1970-01-01
      • 2015-07-08
      • 1970-01-01
      • 2018-02-15
      • 2014-11-06
      • 1970-01-01
      • 1970-01-01
      • 2017-08-18
      • 1970-01-01
      相关资源
      最近更新 更多