在 Rcpp 中选择 NumericVector 和 arma::vec

Posted 2023-02-16

【中文标题】在 Rcpp 中选择 NumericVector 和 arma::vec

【英文标题】：Deciding between NumericVector and arma::vec in Rcpp

【发布时间】：2018-05-04 08:08:21

【问题描述】：

使用 RcppArmadillo，使用 arma::vec 从 R 转换为 Rcpp 与使用 Rcpp 和 NumericVector 一样简单。我的项目使用 RcppArmadillo。

我不确定要使用什么，NumericVector 或 arma::vec？这两者之间的主要区别是什么？什么时候用哪个？使用一个比另一个有性能/内存优势吗？唯一的区别是成员函数吗？而且，作为一个额外的问题：我应该考虑arma::colvec 还是arma::rowvec？

【问题讨论】：

这对于 *** 来说真的不是一个合适的问题。

这可以追溯到... ***.com/questions/41602024/…

【参考方案1】：

这两者之间的主要区别是什么？

Rcpp 中的 *Vector 和 *Matrix 类充当 R 的 SEXP 表示形式的包装器，例如S 表达式，作为指向数据的指针。有关详细信息，请参阅 R Internals 的 Section 1.1 SEXPs。Rcpp 的设计通过从包含指向数据的指针的类构造 C++ 对象来利用这一点。这促进了两个关键特性：

R 和 C++ 对象之间的无缝传输，以及 R 和 C++ 之间的传输成本低，因为只传递了一个指针。 因为数据不是复制，而是引用

同时，arma 对象类似于传统的std::vector<T>，在R 和C++ 之间发生深 复制> 对象。这个语句有一个例外，advanced constructor 的存在，它允许 R 对象后面的内存在armadillo 对象的结构中重用 .因此，如果您不小心，您可能会在从 R 到 C++ 的转换过程中招致不必要的惩罚，反之亦然。

注意：允许重用内存的高级构造函数不存在于arma::sp_mat。因此，在从 R 到 C++ 并返回的复制过程中，使用具有稀疏矩阵的引用可能不会产生所需的加速。 p>

您可以在很大程度上基于“传递引用”或“传递复制”范式查看差异。要了解代码之外的差异，请考虑以下mathwarehouse 的 GIF：

为了在代码中说明这种情况，请考虑以下三个函数：

#include <RcppArmadillo.h>

// [[Rcpp::depends(RcppArmadillo)]]

// [[Rcpp::export]]
void memory_reference_double_ex(arma::vec& x, double value) 
    x.fill(value);


// [[Rcpp::export]]
void memory_reference_int_ex(arma::ivec& x, int value) 
    x.fill(value);


// [[Rcpp::export]]
arma::vec memory_copy_ex(arma::vec x, int value) 
    x.fill(value);
    return x;

假设存在适当的数据类型，memory_reference_double_ex() 和memory_reference_int_ex() 两个函数将更新R 的inside 对象。因此，我们可以通过在定义中指定void 来避免返回值，因为x 分配的内存正在被重用。第三个函数memory_copy_ex() 需要返回类型，因为它是按副本传递的，因此，不会在没有重新分配调用的情况下修改现有存储。

强调：

x 向量将通过引用传递到 C++，例如& 在arma::vec& 或arma::ivec& 的末尾，以及 R 中x 的类是double 或integer，这意味着我们匹配arma::vec 的底层类型，例如Col<double> 或arma::ivec，例如Col<int>。

让我们快速看两个例子。

在第一个示例中，我们将查看运行memory_reference_double_ex() 的结果并将其与memory_copy_ex() 生成的结果进行比较。请注意，R 和 C++ 中定义的对象之间的类型是相同的（例如double）。在下一个示例中，这将不成立。

x = c(0.1, 2.3, 4.8, 9.1)
typeof(x)
# [1] "double"

x
# [1] 0.1 2.3 4.8 9.1

# Nothing is returned...
memory_reference_double_ex(x, value = 9)

x
# [1] 9 9 9 9

a = memory_copy_ex(x, value = 3)

x
# [1] 9 9 9 9

a
#      [,1]
# [1,]    3
# [2,]    3
# [3,]    3
# [4,]    3

现在，如果 R 对象的基础类型是 integer 而不是 double，会发生什么？

x = c(1L, 2L, 3L, 4L)
typeof(x)
# [1] "integer"

x
# [1] 1 2 3 4

# Return nothing...
memory_reference_double_ex(x, value = 9)

x
# [1] 1 2 3 4

发生了什么？为什么x 没有更新？嗯，在幕后Rcpp 创建了一个新的内存分配，它是正确的类型——double 而不是int——然后将它传递给armadillo。这导致两个对象之间的引用“链接”不同。

如果我们更改为在armadillo 向量中使用整数数据类型，请注意我们现在具有与之前相同的效果：

memory_reference_int_ex(x, value = 3)

x
# [1] 3 3 3 3

这引发了对这两种范式有用性的讨论。由于 speed 是使用 C++ 时的首选基准，让我们从基准的角度来看待它。

考虑以下两个函数：

#include <RcppArmadillo.h>

// [[Rcpp::depends(RcppArmadillo)]]

// [[Rcpp::export]]
void copy_double_ex(arma::vec x, double value) 
    x.fill(value);


// [[Rcpp::export]]
void reference_double_ex(arma::vec& x, double value) 
    x.fill(value);

对它们运行微基准测试会产生：

# install.packages("microbenchmark")
library("microbenchmark")

x = rep(1, 1e8)

micro_timings = microbenchmark(copy_double_ex(x, value = 9.0),
                               reference_double_ex(x, value = 9.0))
autoplot(micro_timings)
micro_timings

# Unit: milliseconds
#                               expr       min        lq      mean    median        uq      max neval
#       copy_double_ex(x, value = 9) 523.55708 529.23219 547.22669 536.71177 555.00069 640.5020   100
#  reference_double_ex(x, value = 9)  79.78624  80.70757  88.67695  82.44711  85.73199 308.4219   100

注意：每次迭代引用的对象比复制的范例快约 6.509771 倍，因为我们这样做不必重新分配和填充该内存。

什么时候用哪个？

你需要做什么？

您是否只是想快速加速依赖循环但不需要严格的线性代数操作的算法？

如果是这样，只需使用 Rcpp 就足够了。

您是否尝试执行线性代数运算？ 或者您是否希望在多个库或计算平台（例如 MATLAB、Python、R...）中使用此代码？

如果是这样，您应该在 armadillo 中编写算法的关键，并设置适当的挂钩以使用 Rcpp 将函数导出到 R em>。

使用其中一种是否具有性能/内存优势？

是的，如前所述，确实具有性能/内存优势。不仅如此，通过使用 RcppArmadillo，您实际上是在 Rcpp 之上添加了一个额外的库，因此增加了整体安装占用空间、编译时间和系统要求（参见macOS 构建的困境）。找出您的项目需要什么，然后选择该结构。

唯一的区别是成员函数吗？

不仅是成员函数，还有：

矩阵分解方面的估计例程 计算统计量值 对象生成 稀疏表示（避免操作 S4 对象）

这些是 Rcpp 和 armadillo 之间的基本区别。一个是为了便于将 R 对象转移到 C++，而另一个是为了更严格的线性代数计算。这应该很明显，因为 Rcpp 确实不 实现任何矩阵乘法逻辑，而 armadillo 使用系统的基本线性代数子程序 (BLAS) 来执行计算。

还有一个额外的问题：我应该考虑 arma::colvec 还是 arma::rowvec？

取决于您希望如何返回结果。你想要一个：1 x N（行向量）还是N x 1（列向量）？ RcppArmadillo 默认情况下将这些结构返回为具有适当尺寸的 矩阵 对象，并且不是传统的一维 R 向量。

举个例子：

#include <RcppArmadillo.h>

// [[Rcpp::depends(RcppArmadillo)]]

// [[Rcpp::export]]
arma::vec col_example(int n) 
    arma::vec x = arma::randu<arma::vec>(n);
    return x;



// [[Rcpp::export]]
arma::rowvec row_example(int n) 
    arma::rowvec x = arma::randu<arma::rowvec>(n);
    return x;

测试：

set.seed(1)
col_example(4)
#           [,1]
# [1,] 0.2655087
# [2,] 0.3721239
# [3,] 0.5728534
# [4,] 0.9082078

set.seed(1)
row_example(4)
#           [,1]      [,2]      [,3]      [,4]
# [1,] 0.2655087 0.3721239 0.5728534 0.9082078

【参考方案2】：

@coatless 的答案是正确的，但会用你没有要求的细节来为你服务。

同时，您的问题未明确说明，因为您没有说明您需要向量做什么。有了这个警告，我会说

对于简单的用例，Rcpp 很好，RcppArmadillo 也很好 对于需要线性代数的用例，首选 RcppArmadillo 性能在很大程度上是相同的，但需要注意的是，如上所述，您需要对 RcppArmadillo 进行显式“引用调用” 只读向量访问（例如，sum() 或 min() 或查找之类的缩减）与读写访问之间也存在很大差异，这对您如何返回修改后的向量很重要 所有用例通常都比 R 代码快得多，因此在第一个实例中不要为此而烦恼。

一旦你做对了，你就可以（也许应该）配置文件。