标签: vectorization

我有一个矩阵,matrix_logical(50000,100000),这是一个稀疏的逻辑矩阵(很多谬误,有些是真的).我必须生成一个矩阵,相交(50000,50000),对于每对,i,j,matrix_logical(50000,100000)的行,存储行i和j都具有"true"的列数作为价值.

这是我写的代码:

% store in advance the nonzeros cols
for i=1:50000
    nonzeros{i} = num2cell(find(matrix_logical(i,:)));
end

intersect = zeros(50000,50000);

for i=1:49999
    a = cell2mat(nonzeros{i});
    for j=(i+1):50000
        b = cell2mat(nonzeros{j});
        intersect(i,j) = numel(intersect(a,b));
    end
end

是否有可能进一步提高性能？计算矩阵需要很长时间.我想避免代码的第二部分中的双循环.

matrix_logical是稀疏的,但在MATLAB中它没有保存为稀疏,因为否则性能变得最差.

是否可以矢量化以下函数,(f)？

我有一个向量x,我希望f通过更改来最大化函数的输出值p.

但是这个功能很慢,因为它无论如何都没有矢量化,并且想知道是否有一个好方法.我们的想法是在未来将其并行化,并且还可能用于data.table加速它

我的真实数据要大得多......所以我提供了一个模拟示例....

# My mock data 
x <- data.frame(x=rep(c(rep(c(0.2,-0.2),4),0.2,0.2,-0.2,0.2),20))

# The function to optimise for
f <- function(p,x){
    # Generate columns before filling
    x$multiplier <- NA
    x$cumulative <- NA

    for(i in 1:nrow(x)){
        # Going through each row systematically
        if(i==1){
            # If first row do a slightly different set of commands
            x[i,'multiplier'] <- 1 * p
            x[i,'cumulative'] <- (x[i,'multiplier'] * x[i,'x']) + 1
        } else {
            # For the …

我正在使用一个包含大约300万个观测值的非常大的数据集,而且如果它们符合特定要求,我想要完成并基本上将某些观测结合起来.我在下面写了一个for循环来做这个,但效率非常低.是否有一种更有效的方式,例如使用apply函数或其他东西,可以改善这一点？

nobs <- nrow(acsdata)

for (i in 2:nobs){

  if (acsdata[i,6]==1 & acsdata[(i-1),6]==1) acsdata[(i-1),3]=2  

  if (acsdata[i,6]==1 & acsdata[(i-1),6]==1) acsdata[(i-1),21:30]=acsdata[(i-1),21:30]+acsdata[i,21:30]

  if (acsdata[i,6]==1 & acsdata[(i-1),6]==1) acsdata[(i),31]=1

}

任何帮助将不胜感激.谢谢!

我目前正在尝试使用g ++进行自动向量化.为此,我使用以下最小示例:

#include <array>
int main()
{
    std::array<double, 16> x;
    for (unsigned int i = 0; i < 16; i++) x[i] = i;
    return x[15];
}

我编译:

g++-4.7 -Wall -Wextra -std=c++11 -O3 -ftree-vectorizer-verbose=9 tests.cpp -o tests

结果是:

Analyzing loop at tests.cpp:5

5: ===== analyze_loop_nest =====
5: === vect_analyze_loop_form ===
5: === get_loop_niters ===
5: ==> get_loop_niters:16
5: === vect_analyze_data_refs ===

5: not vectorized: no vectype for stmt: MEM[(value_type &)&x]._M_instance[i_21] = D.21296_5;
 scalar_type: value_type
5: bad data references.
tests.cpp:2: note: vectorized …

题:

我正在寻找在指定行之前将多行R插入矩阵的最有效方法,同时将现有行向下移动.MI

例:

M = [1 1 1 1;
     2 2 2 2;
     3 3 3 3;
     4 4 4 4;
     5 5 5 5];
I = [1 3 3 5];
R = [-6 -6 -6 -6;
     -7 -7 -7 -7;
     -8 -8 -8 -8
     -9 -9 -9 -9];

结果应该是矩阵:

[-6 -6 -6 -6
  1  1  1  1
  2  2  2  2
 -7 -7 -7 -7
 -8 -8 -8 -8
  3  3  3  3
  4  4 …

我正在寻找一种解决方案,通过在R中应用矢量化来实现以下简单的增长率公式:

gr <- function(x){
a <- matrix(,nrow=nrow(x),ncol=ncol(x))
   for (j in 1:ncol(x)){
      for (i in 2:nrow(x)){
        if (!is.na(x[i,j]) & !is.na(x[i-1,j]) & x[i-1,j] != 0){
           result[i,j] <- x[i,j]/x[i-1,j]-1 
        }
       }
    }
return(a)
}

我发现xts包会产生时间序列的滞后,但最后我总是不得不与许多值进行比较(见上文),所以我不能简单地使用ifelse.一个可能的问题是当时间序列(例如价格指数)之间有零.这将NaNs在结果中创建,我试图避免,之后不能简单地删除(编辑:显然他们可以,看下面的答案!)

简而言之:我想为给定的值表生成一个正确增长率的表.这是一个例子:

m <- matrix(c(1:3,NA,2.4,2.8,3.9,0,1,3,0,2,1.3,2,NA,7,3.9,2.4),6,3)

产生:

      [,1] [,2] [,3]
[1,]  1.0  3.9  1.3
[2,]  2.0  0.0  2.0
[3,]  3.0  1.0   NA
[4,]   NA  3.0  7.0
[5,]  2.4  0.0  3.9
[6,]  2.8  2.0  2.4

正确的结果,产生于gr(m):

           [,1] [,2]       [,3]
[1,]        NA   NA         NA
[2,] 1.0000000 …

这是代码

S = size(shape,3)
shape = 1 - shape;

for i = 2:S
    SHAPE = prod(shape(:,:,1:i-1),3);
    for c = 1:3
        vision(:,:,c,i) = vision(:,:,c,i).*SHAPE;
    end
end

output = sum(vision,4);

也许有一种方法来矢量化它？

顺便说一下shape,SHAPE它们是0和1的数组,因此它们可能以某种方式被用作逻辑.

我正在努力使用以下代码:

import numpy as np

e = np.linspace(0, 4, 10)

def g(x):
    if x > 1:
        return x
    else:
        return 0

vg = np.vectorize(g)

print(vg(e))

结果如下:

    [0 0 0 1 1 2 2 3 3 4]

我也检查了dtype.似乎vectorize函数正在从float64将类型转换为int64!

给定具有形状(n,k)的矩阵A和大小为n的向量s,我想要计算具有形状(k,k)的矩阵G,如下所示:

对于{0,...,n-1}中的所有i,G + = s [i]*A [i] .T*A [i]

我尝试使用for循环(方法1)和矢量化方法(方法2)来实现它,但对于大的k值(特别是当k> 500时),for循环实现更快.

代码编写如下:

import numpy as np
k = 200
n = 50000
A = np.random.randint(0, 1000, (n,k)) # generates random data for the matrix A (n,k)
G1 = np.zeros((k,k)) # initialize G1 as a (k,k) matrix
s = np.random.randint(0, 1000, n) * 1.0 # initialize …

我有一个名为的3D矩阵mat.每列可以包含或不包含可变数量的前导零.我需要用NaN替换它们.重要的是要认识到在第一个非零元素出现后,任何列中可能会跟随更多的零.也就是说,只需在矩阵中索引全零并用NaN替换它们就不会产生正确的结果.

我确实有一个有效的解决方案.但是,它包含两个for循环.我想知道是否有可能进行矢量化并摆脱循环.实际上,mat可能非常大,比如10000x15x10000.因此,我对执行速度非常敏感.

这是我的玩具示例:

% Create test matrix
mat = randi(100,20,5,2);
mat(1:5,1,1) = 0;
mat(1:7,2,1) = 0;
mat(1:3,4,1) = 0;
mat(1:10,5,1) = 0;
mat(1:2,1,2) = 0;
mat(1:3,3,2) = 0;
mat(1:7,4,2) = 0;
mat(1:4,5,2) = 0;

% Find first non-zero element in every column
[~, firstNonZero] = max( mat ~= 0 );

% Replace leading zeros with NaN
% How to vectorize this part???
[nRows, nCols, nPlanes] = size(mat);
for j = 1 : nPlanes

   for i = …