Question

如果其中一些是我无法理解的基本C ++，我会提前道歉。

在展示我的代码之前，让我解释一下我想要实现的目标。我有一个稀疏的矩阵U和一个向量r，我想计算(U-r)(U-r)'，其中减法是针对U的每一列。

但是，我无法一次完成所有这一切，因为U-r密集且爆炸内存使用（约700万列与~20,000行）。

利用外部产品XX'可以一次计算一列XX' == sum(XcXc')，其中sum是矩阵添加的事实，我的策略是采用多个列，做减法和外部产品并积累结果。一次仅使用几列可以将内存使用量降低到非常合理的数量（几百MB）。

从表面上看，这需要2份20,000 x 20,000矩阵（每份3.5 GB），一份用于累计结果，一份用于临时右手侧。但是，由于我不明白的原因，根据观察到的内存使用情况，我有3份副本。

因为我想尽可能地并行化这个操作（这是非常昂贵的），减少内存使用是至关重要的。

所以，第1步是让我从3份拷贝到2份。

如果可能的话，步骤2是要意识到没有理由不在RHS上实现结果。也就是说，没有理由不继续将结果添加到累积矩阵的每个元素中，而不是在RHS上创建临时矩阵，然后对累加器矩阵执行加法。

步骤3，通过利用产生对称矩阵的事实来减少计算时间。我认为这是通过.selfadjointView（Lower）完成的，但我无法解析如何在一致的基础上继续这样做。

最后，代码。我在R中进行并行化，这段代码只代表一个并行化过程。我传递了列索引的连续向量列表来计算。

// [[Rcpp::depends(RcppEigen)]] 
#include <iostream>
#include "Rcpp.h"
#include "RcppEigen.h"
#include "Eigen/Dense"
#include "Eigen/Sparse"

using Eigen::MatrixXd;

typedef Eigen::MappedSparseMatrix<double> MSpMat;
typedef Eigen::Map<Eigen::VectorXd> MVec;
typedef Eigen::Map<MatrixXd> MMat;



/*
 * tcrossprod_cpp just compute X * X' where X is a matrix, * is matrix
 * multiplication and ' is transpose, but in an efficient manner,
 * although it appears that R's tcrossprod is actually faster. Pulled it from
 * the RcppEigen book.
 */


MatrixXd tcrossprod_cpp(const MatrixXd &U) {
    const long m(U.rows());
    MatrixXd UUt(MatrixXd(m, m).setZero().
            selfadjointView<Eigen::Lower>().rankUpdate(U));
    return UUt;
}

// [[Rcpp::export]]
MatrixXd gen_Sigma_cpp_block_sp(const Rcpp::List &col_list, const MSpMat &U,
                                const MVec &r, int index1 = 1) {
    long nrow = U.rows();
    MatrixXd out = MatrixXd::Constant(nrow, nrow, 0.0);
    long ncol;
    Rcpp::IntegerVector y;
    for (long i = 0; i < col_list.size(); i++) {
        if (i % 10 == 0) {
            Rcpp::checkUserInterrupt();
        }
        y = col_list[i];
        ncol = y[y.size() - 1] - y[0] + 1;
        out.noalias() += tcrossprod_cpp((MatrixXd (U.block(0, y[0] - index1,
                                         nrow, ncol))).colwise() - r);
    }
    return out;
}

Answer 1

你应该重写你的表达。在数学上，从import requests from bs4 import BeautifulSoup webpage = requests.get("http://www.nytimes.com/") soup = BeautifulSoup(requests.get("http://www.nytimes.com/").text, "html.parser") articles = [story_heading.text.strip() for story_heading in soup.find_all(class_="story-heading")] print (articles)的每一列中减去r与U相同（其中U - r*ones是与ones具有相同列数的行向量）。扩展为您提供：

(U-r*ones)*(U-r*ones)^T = U*U^T - (U*ones^T)*r^T - r*(ones*U^T) + r*(ones*ones^T)*r^T等于ones*ones^T，U.cols()可以计算为U*ones^T并存储到密集向量中。剩下的操作是U*VectorXd::Ones(U.cols())的稀疏产品（你可以直接存储到密集矩阵中，因为你的最终结果是密集的，然后是两个等级更新：

U*U.transpose()

回答有关额外临时工的问题：在VectorXd Usum = U * VectorXd::Ones(U.cols()); // sum of columns of U MatrixXd result = U*U.transpose(); result.selfadjointView<Lower>().rankUpdate(Usum, r, -1.0); result.selfadjointView<Lower>().rankUpdate(r,U.cols());内，您可以创建一个临时tcrossprod_cpp，然后将结果存储到MatrixXd(m,m)。你可以完全避免这种方法，直接写

MatrixXd UUt

编辑：在Eigen 3.3（我用3.3rc1测试）之前，显然不可能直接将稀疏产品分配给密集矩阵。如果有可能，我建议切换到3.3版本（还有许多其他改进）。

Answer 2

我无法编译chtz的代码。我本来希望能给出答案，但是用户Michael Albers认为编辑响应以包含正确的代码是不可接受的。所以我必须创建一个正确答案的新帖子。

在转换为密集矩阵之前，我必须为U的外积创建一个中间稀疏矩阵。这似乎不太理想，我已经看到其他人有这个问题，但没有办法绕过它。在任何情况下，这个结果都会编译：

// [[Rcpp::export]]
MatrixXd gen_Sigma_cpp_sp(const MSpMat &U, const MVec &r) {
    VectorXd UcolSum = U * VectorXd::Ones(U.cols());
    MatrixXd S = MatrixXd(SparseMatrix<double>(U * U.transpose())).
                    selfadjointView<Lower>().rankUpdate(UcolSum, r, -1.0).
                                             rankUpdate(r, U.cols());
    return S;
}

对于任何使用R的人来说，我必须在强制键入＆＃39; dpoMatrix＆＃39;之前将其包装在forceSymmetric中，这就是普通的tcrossprod（U-r）所给出的，并帮助最多的计算：

SigmaS0 = as(forceSymmetric(gen_Sigma_cpp_sp(U, r), 'L'), 'dpoMatrix')

特征：如何防止大型物体的额外副本;分配到结果而没有在RHS上实现完整矩阵

2 个答案: