标签: vectorization

我有一个数组X,我想将一个函数f应用于所有行X:

# silly example
X = numpy.array([[1, 2, 3, 4, 5],
                 [6, 7, 8, 9, 0]], 'i')

def f(row): return sum(row)

y = numpy.vectorize(f, 'i')(rows(X))

现在,y应该是array([15,30], 'i').哪种方法或切片魔术将以rows最有效的方式实施？

我试图优化一个占我程序计算时间很多的循环.

但是当我使用-O3 -ffast-math -ftree-vectorizer-verbose = 6 GCC输出打开自动矢量化时,它无法对循环进行矢量化.

我正在使用GCC 4.4.5

代码:

/// Find the point in the path with the largest v parameter
void prediction::find_knife_edge(
    const float * __restrict__ const elevation_path,
    float * __restrict__ const diff_path,
    const float path_res,
    const unsigned a,
    const unsigned b,
    const float h_a,
    const float h_b,
    const float f,
    const float r_e,
) const
{
    float wavelength = (speed_of_light * 1e-6f) / f;

    float d_ab = path_res * static_cast<float>(b - a);

    for (unsigned n = a …

我想__m256使用AVX指令水平地对矢量的分量求和.在SSE我可以使用

_mm_hadd_ps(xmm,xmm);
_mm_hadd_ps(xmm,xmm);

在向量的第一个组件处获得结果,但这不能与函数(_mm256_hadd_ps)的256位版本一起扩展.

计算__m256向量水平和的最佳方法是什么？

R中是否有一个函数可以有效地检查一个值是否大于一个且小于另一个数字？它也应该与矢量一起使用.

基本上,我正在寻找以下功能的更快版本:

> in.interval <- function(x, lo, hi) (x > lo & x < hi)
> in.interval(c(2,4,6), 3, 5)
[1] FALSE  TRUE FALSE

这里的问题是x必须触摸两次,并且与更有效的方法相比,计算消耗两倍的内存.在内部,我会假设它像这样工作:

1. 计算 tmp1 <- (x > lo)
2. 计算 tmp2 <- (x < hi)
3. 计算 retval <- tmp1 & tmp2

现在,在步骤2之后,两个布尔向量在内存中,并且x必须两次查看.我的问题是:是否有一个(内置？)函数可以一步完成所有这些,而无需分配额外的内存？

跟进此问题:R:从范围内的数据表中选择值

编辑:我已经根据CauchyDistributedRV的答案设置了一个Gist,网址是https://gist.github.com/4344844

是否有矢量化方式来执行以下操作？(以示例显示):

input_lengths = [ 1 1 1 4       3     2   1 ]
result =        [ 1 2 3 4 4 4 4 5 5 5 6 6 7 ]

我已经间隔了input_lengths,因此很容易理解如何获得结果

合成矢量的长度为:sum(lengths).我目前result使用以下循环计算:

result = ones(1, sum(input_lengths ));
counter = 1;
for i = 1:length(input_lengths)
    start_index = counter;
    end_index = counter + input_lengths (i) - 1;

    result(start_index:end_index) = i;
    counter = end_index + 1;
end

编辑:

我也可以使用arrayfun(虽然这不是一个矢量化函数)

cell_result = arrayfun(@(x) repmat(x, 1, input_lengths(x)), 1:length(input_lengths), 'UniformOutput', false);
cell_result : …

假设我们有以下pandas DataFrame:

In [1]:
import pandas as pd
import numpy as np

df = pd.DataFrame([0, 1, 0, 0, 1, 1, 0, 1, 1, 1], columns=['in'])
df
Out[1]: 
   in
0   0
1   1
2   0
3   0
4   1
5   1
6   0
7   1
8   1
9   1

如何在熊猫中以矢量化方式计算连续数？我希望得到这样的结果:

   in  out
0   0    0
1   1    1
2   0    0
3   0    0
4   1    1
5   1    2
6   0    0
7   1    1
8   1    2 …

将rgb图像转换为灰度图像的两个函数:

function rgb2gray_loop{T<:FloatingPoint}(A::Array{T,3})
  r,c = size(A)
  gray = similar(A,r,c)
  for i = 1:r
    for j = 1:c
      @inbounds gray[i,j] = 0.299*A[i,j,1] + 0.587*A[i,j,2] + 0.114 *A[i,j,3]
    end
  end
  return gray
end

和:

function rgb2gray_vec{T<:FloatingPoint}(A::Array{T,3})
  gray = similar(A,size(A)[1:2]...)
  gray = 0.299*A[:,:,1] + 0.587*A[:,:,2] + 0.114 *A[:,:,3]
  return gray
end

第一个是使用循环,而第二个使用矢量化.

在对它们进行基准测试时(使用Benchmark包),我得到了不同大小的输入图像的以下结果(f1是循环版本,f2矢量化版本):

A = rand(50,50,3):

| Row | Function | Average     | Relative | Replications |
|-----|----------|-------------|----------|--------------|
| 1   | "f1"     | 3.23746e-5  | 1.0      | 1000 …

这是一个SSCCE:

class Vec final {
    public:
        float data[4];

        inline Vec(void) {}
        inline ~Vec(void) {}
};
Vec operator*(float const& scalar, Vec const& vec) {
    Vec result;
    #if 1
        for (int k=0;k<4;++k) result.data[k]=scalar*vec.data[k];
    #else
        float const*__restrict src =    vec.data;
        float      *__restrict dst = result.data;
        for (int k=0;k<4;++k) dst[k]=scalar*src[k];
    #endif
    return result;
}

int main(int /*argc*/, char* /*argv*/[]) {
    Vec vec;
    Vec scaledf = 2.0f * vec;
    return 0;
}

编译时,MSVC 2013通知我(/Qvec-report:2)

main.cpp(11):info C5002:由于'1200'原因,循环未向量化

这意味着"[l] oop包含循环携带的数据依赖性".

我注意到,对构造函数或析构函数进行注释Vec(编辑:或者默认它们,例如 …

dummies  = matrix(c(0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 
0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0), nrow=6, ncol=6) 
colnames(dummies)  <- c("a","b", "c", "d", "e", "f")

我有一个假人矩阵

> dummies
     a b c d e f
[1,] 0 0 0 0 1 0
[2,] 0 0 1 0 0 0
[3,] 1 0 0 0 0 0
[4,] 0 0 …

您好我正在尝试找到迭代问题的矢量化(或更有效)解决方案,其中我发现的唯一解决方案需要逐行迭代具有多个循环的DataFrame.实际的数据文件是巨大的,所以我目前的解决方案实际上是不可行的.如果你想看一下,我在最后包括了行分析器输出.真正的问题非常复杂,所以我将尝试用一个简单的例子来解释这个问题(花了我一段时间来简化它:)):

假设我们有一个机场有两个并排的着陆带.每架飞机降落(到达时间),在其中一个着陆带上停放一段时间,然后起飞(起飞时间).所有内容都存储在Pandas DataFrame中,按照到达时间进行排序,如下所示(有关更大的测试数据集,请参阅EDIT2):

PLANE   STRIP   ARRIVAL   DEPARTURE
0       1       85.00     86.00
1       1       87.87     92.76
2       2       88.34     89.72
3       1       88.92     90.88
4       2       90.03     92.77
5       2       90.27     91.95
6       2       92.42     93.58
7       2       94.42     95.58

寻找两种情况的解决方案:

1.构建一个事件列表,其中一次在一个条带上存在多个平面.不包括事件子集(例如,如果存在有效的[3,4,5]情况,则不显示[3,4]).该列表应存储实际DataFrame行的索引.有关此案例的解决方案,请参阅函数findSingleEvents()(运行大约5 ms).

2.建立一个事件列表,每次在每个条带上至少有一个平面.不计算事件的子集,仅记录具有最大平面数的事件.(例如,如果有[3,4,5]个案,则不显示[3,4]).不要计算单个条带上完全发生的事件.该列表应存储实际DataFrame行的索引.有关此案例的解决方案,请参阅函数findMultiEvents()(运行大约15 ms).

工作守则:

import numpy as np
import pandas as pd
import itertools
from __future__ import division

data =  [{'PLANE':0, 'STRIP':1, 'ARRIVAL':85.00, 'DEPARTURE':86.00},
         {'PLANE':1, 'STRIP':1, 'ARRIVAL':87.87, 'DEPARTURE':92.76},
         {'PLANE':2, 'STRIP':2, 'ARRIVAL':88.34, 'DEPARTURE':89.72},
         {'PLANE':3, 'STRIP':1, 'ARRIVAL':88.92, …