标签: vectorization

让x=1:100与N=1:10.我想创建一个矩阵,x^N以便i^第th列包含条目[1 i i^2 ... i^N].

我可以使用for循环轻松完成此操作.但有没有办法使用矢量化代码？

我需要什么？[无序列表]

• 非常简单的并行化
• 支持地图,过滤等
• 执行基于数组计算能力有效地,如A = B + C,有点像MATLAB阵列.
• 生成SIMD代码.我想这在不久的将来是不可能的任何事情,但嘿,我可以问:)
• 对矩阵的支持应该至少存在,更高的维度现在是较低的优先级.
• 能够获得指向它的指针并从C指针创建一个指针.
• 其他图书馆的支持.IE,绑定到流行的C数学包,i/o到磁盘或图像,如果数组是2D

我看到了什么？

• haskell-platform中的数组包.这是幸运的,可以并行
• Data.Vector.有循环融合,但不是在平台上,所以它的成熟度对我来说是未知的.
• 维修包,由DPH团队提供,但今天对任何稳定的ghc都不能很好地运作.
• 阵列实现的支持级别有很多变化.例如,似乎没有一种简单的方法将2D矢量转储到图像文件.IOW,haskell社区显然还没有确定阵列实现.

所以,请帮我选择.

编辑 A = B + C指的是元素加法,而不是列表串联

我有两个有序的numpy数组,我想交错它们,以便我从第一个数组中取出一个项目,然后从第二个数据中获取另一个项目,然后返回到第一个 - 获取下一个项目大于我刚刚从中获取的项目第二个等等.这些实际上是其他数组的索引数组,只要操作是向量化的,我就可以对原始数组进行操作(但当然,作为向量操作处理索引数组会非常棒).

示例(可以假设数组的交集为空)

a = array([1,2,3,4,7,8,9,10,17])
b = array([5,6,13,14,15,19,21,23])

我想得到[1,5,7,13,17,19]

我有一个大的10,000,000长度数组,包含行.我需要单独洗牌那些行.例如:

[[1,2,3]
 [1,2,3]
 [1,2,3]
 ...
 [1,2,3]]

至

[[3,1,2]
 [2,1,3]
 [1,3,2]
 ...
 [1,2,3]]

我正在使用

map(numpy.random.shuffle, array)

但它是一个python(而不是NumPy)循环,它占用了99%的执行时间.可悲的是,PyPy JIT没有实现numpypy.random,所以我运气不好.有没有更快的方法？我愿意用任何库(pandas,scikit-learn,scipy,theano,等,只要它使用一个numpy的ndarray或衍生物.)

如果没有,我想我会使用Cython或C++.

我有这个函数来计算向量x的平方Mahalanobis距离意味着:

def mahalanobis_sqdist(x, mean, Sigma):
   '''
    Calculates squared Mahalanobis Distance of vector x 
    to distibutions' mean 
   '''
   Sigma_inv = np.linalg.inv(Sigma)
   xdiff = x - mean
   sqmdist = np.dot(np.dot(xdiff, Sigma_inv), xdiff)
   return sqmdist

我有一个形状为的numpy数组(25, 4).所以,我想在没有for循环的情况下将该函数应用于我的数组的所有25行.那么,基本上,我该如何编写这个循环的矢量化形式:

for r in d1:
    mahalanobis_sqdist(r[0:4], mean1, Sig1)

在哪里mean1和Sig1是:

>>> mean1
array([ 5.028,  3.48 ,  1.46 ,  0.248])
>>> Sig1 = np.cov(d1[0:25, 0:4].T)
>>> Sig1
array([[ 0.16043333,  0.11808333,  0.02408333,  0.01943333],
       [ 0.11808333,  0.13583333,  0.00625   ,  0.02225   ],
       [ 0.02408333,  0.00625   , …

我发现很难找到解决以下问题的快速解决方案:

我有一个观察矢量,它表明观察某些现象的时间.

example <- c(0,0,0,1,0,1,1,0,0,0,-1,0,0,-1,-1,0,0,1,0,0);

现在我想在特定观察之间消除零,假设某个现象被认为会继续,直到发现一个矛盾的观察结果,即,如果在第三次观察中观察到''1',我想只有''1 ''到第11个元素,当第一个'-1'被观察到时.所以我想要的输出看起来像:

desired.output <- c(0,0,0,1,1,1,1,1,1,1,-1,-1,-1,-1,-1,-1,-1,1,1,1);

> print(cbind(example, desired.output))
      example desired.output
 [1,]       0              0
 [2,]       0              0
 [3,]       0              0
 [4,]       1              1
 [5,]       0              1
 [6,]       1              1
 [7,]       1              1
 [8,]       0              1
 [9,]       0              1
[10,]       0              1
[11,]      -1             -1
[12,]       0             -1
[13,]       0             -1
[14,]      -1             -1
[15,]      -1             -1
[16,]       0             -1
[17,]       0             -1
[18,]       1              1
[19,]       0              1
[20,]       0              1

我的蹩脚解决方案是

for (i in 1:length(example)){ …

该Vectorize()和apply()功能R往往可以用来完成相同的目标.出于可读性的原因,我通常更喜欢向量化函数,因为主调用函数与手头的任务有关,而sapply不是.Vectorize()当我在R代码中多次使用该向量化函数时,它也很有用.例如:

a <- 100
b <- 200
c <- 300
varnames <- c('a', 'b', 'c')

getv <- Vectorize(get)
getv(varnames)

VS

sapply(varnames, get)

但是,至少在SO上我很少看到Vectorize()解决方案中的例子,只有apply()(或其中一个兄弟姐妹).是否有任何效率问题或其他合理问题Vectorize()可以做出apply()更好的选择？

有没有一种方法,我可以使用SciPy的功能就像在地方上一个(或)使用的变体,等等？norm.cdf numpy.arraypandas.DataFramenumpy.applynumpy.apply_along_axs

背景是,我有一个z得分值表,我想将其转换为规范分布的CDF值.我目前使用norm.cdf的scipy这一点.

我目前正在操纵具有非数字值的数据帧.

      Name      Val1      Val2      Val3      Val4 
0        A -1.540369 -0.077779  0.979606 -0.667112   
1        B -0.787154  0.048412  0.775444 -0.510904   
2        C -0.477234  0.414388  1.250544 -0.411658   
3        D -1.430851  0.258759  1.247752 -0.883293   
4        E -0.360181  0.485465  1.123589 -0.379157

(使Name变量成为索引是一种解决方案,但在我的实际数据集中,名称不是字母字符.)

要仅修改数字数据,我使用df._get_numeric_data()的私有函数返回包含数据框的数字数据的数据框.但是,没有任何set功能.因此,如果我打电话

norm.cdf(df._get_numeric_data)

这不会改变df原始数据.

我试图通过应用norm.cdf到数字数据框来避免这种情况,因此这会改变我的原始数据集.

你如何优化这个代码(没有向量化,因为这会导致使用计算的语义,这通常远非重要):

slow_lib.py:
import numpy as np

def foo():
    size = 200
    np.random.seed(1000031212)
    bar = np.random.rand(size, size)
    moo = np.zeros((size,size), dtype = np.float)
    for i in range(0,size):
        for j in range(0,size):
            val = bar[j]
            moo += np.outer(val, val)

关键是这种类型的循环经常与对某些向量运算有双重和的运算相对应.

这很慢:

>>t = timeit.timeit('foo()', 'from slow_lib import foo', number = 10)
>>print ("took: "+str(t))
took: 41.165681839

好的,那么让我们把它狠毒化并添加类型注释,就像没有明天一样:

c_slow_lib.pyx:
import numpy as np
cimport numpy as np
import cython
@cython.boundscheck(False)
@cython.wraparound(False)

def foo():
    cdef int size = 200
    cdef int i,j …

我写了一个递归函数,然而,它需要花费很多时间.因此我对它进行了矢量化,但它不会产生与递归函数相同的结果.这是我的非矢量化代码:

function visited = procedure_explore( u, adj_mat, visited )
visited(u) = 1;
neighbours = find(adj_mat(u,:));
for ii = 1:length(neighbours)
    if (visited(neighbours(ii)) == 0)
        visited = procedure_explore( neighbours(ii), adj_mat, visited );
    end
end
end

这是我的矢量化代码:

function visited = procedure_explore_vec( u, adj_mat, visited )
visited(u) = 1;
neighbours = find(adj_mat(u,:));
len_neighbours=length(neighbours);
visited_neighbours_zero=visited(neighbours(1:len_neighbours)) == 0;
if(~isempty(visited_neighbours_zero))
    visited = procedure_explore_vec( neighbours(visited_neighbours_zero), adj_mat, visited );
end
end

这是测试代码

function main
    adj_mat=[0 0 0 0;
             1 0 1 1;
             1 0 0 0;
             1 0 0 …