标签: vectorization

我有两个 DataFrames 。. .

df1 是一个表，我需要从使用索引中提取值，从 df2 中的多个列中检索的列对。

我看到有一个函数get_value在给定索引和列值时可以完美运行，但是当尝试矢量化此函数以创建新列时，我失败了...

df1 = pd.DataFrame(np.arange(20).reshape((4, 5)))

df1.columns = list('abcde')

df1.index = ['cat', 'dog', 'fish', 'bird']

        a   b   c   d   e
cat     0   1   2   3   4
dog     5   6   7   8   9
fish    10  11  12  13  14
bird    15  16  17  18  19

df1.get_value('bird, 'c')

17

现在我需要做的是创建一个完整的新列df2- 当df1基于索引进行索引时，来自animal,letter列的列对在df2有效矢量化上述pd.get_value函数时指定。

df2 = pd.DataFrame(np.arange(20).reshape((4, 5)))

df2['animal'] = ['cat', 'dog', 'fish', 'bird'] …

所以我有一个shapely LineString：

print np.round(shapely_intersecting_lines.coords).astype(np.int) 
>>> array([[ 1520, -1140],
           [ 1412,  -973]])

这可以解释为numpy数组以及上面看到的。

我想获得中间的所有点，也就是说，我想获得中间线的点作为整数值。输出应该是这样的：

array([[ 1520, -1140],
       [ 1519, -1139],
       [ 1519, -1138],
       ..., 
       [ 1413,  -975],
       [ 1412,  -974],
       [ 1412,  -973]], dtype=int32)

我早些时候在gis.stackexchange 中发布了这个，希望有一个shapely有效的解决方案。该解决方案起初很好，但是，由于我在代码中运行了 50000 多次，该解决方案现在太慢了。在我的电脑上，每个循环大约需要 0.03 秒，导致运行超过一天。对于我在这里需要的东西来说太慢了，希望看看是否有人知道对此的矢量化解决方案。

我想看看是否有办法矢量化我执行的计算。我搜索了这个答案，但找不到我需要的。

我有一个增长率向量。每个代表一个时期（在我的情况下为一年）。我想将此向量应用于某些本金。然后，在将第一个增长率应用于主体后，使用第一次迭代的结果并将第二个增长元素应用于新值。

这是一些用于复制的代码（全部在 中base）：

# Vector of interest or inflation rates
RateVector <- c(0.02, 0.03, 0.04, 0.05, 0.06, 0.05, 0.04, 0.03, 0.02, 0.01) # forecasted rates
Principal <- data.frame(Principal = 1000000) # actual value of indicator in most recent period as data frame (list)

这是我尝试矢量化：

sapply(Principal, "*", 1 + cumsum(RateVector))

问题在于该sapply函数不会保存新金额，而是将利率向量应用于相同的初始本金。这实际上是我对这段代码的期望。我不知道如何在每次迭代后从元素到元素保存新值。

这就是我使用循环解决问题的方法：

AmountVector <- Principal # initialize output vector

# Compound growth growth calculation loop
for(i in 1:length(RateVector)){
  Principal = Principal * (1 + RateVector)[i]
  AmountVector …

我最近被介绍了向量指令（理论上）并且对如何使用它们来加速我的应用程序感到兴奋。

我想改进的一个方面是一个非常热的循环：

__declspec(noinline) void pleaseVectorize(int* arr, int* someGlobalArray, int* output)
{
    for (int i = 0; i < 16; ++i)
    {
        auto someIndex = arr[i];
        output[i] = someGlobalArray[someIndex];
    }

    for (int i = 0; i < 16; ++i)
    {
         if (output[i] == 1)
         {
             return i;
         }
    }

    return -1;
}

但是，当然，所有 3 个主要编译器（msvc、gcc、clang）都拒绝对此进行矢量化。我可以理解为什么，但我想得到确认。

如果我必须手动矢量化它，它将是：

(1) VectorLoad "arr", 这带来了 16 个 4 字节整数，让我们说到 zmm0

(2) 16个内存从zmm0[0..3]指向的地址加载到zmm1[0..3]，从zmm0[4..7]指向的地址加载到zmm1[4..7]所以等等

(3)比较zmm0和zmm1

(4) 向量 popcnt 到输出中找出最高有效位并基本上除以 8 得到匹配的索引

首先，向量指令可以做这些事情吗？就像他们可以执行这种“收集”操作，即从指向 zmm0 的地址加载？

以下是 clang 生成的内容：

0000000000400530 …

我在 TensorFlow 中有一个 N 维的一维向量，

如何构造成对平方差的总和？

例子

输入向量
[1,2,3]
输出 6
计算为

(1-2)^2+(1-3)^2+(2-3)^2.

如果我将输入作为 N-dim 向量 l，则输出应为 sigma_{i,j}((l_i-l_j)^2)。

添加的问题：如果我有一个 2d 矩阵并且想对矩阵的每一行执行相同的过程，然后对所有行的结果求平均值，我该怎么做？非常感谢！

我想将此代码简化为无需 for 循环即可工作。

for i=1:N
    for j=1:N
        if ismember(j,A)

           PID(i,i)=TFP(i,j)+ PID(i,i);

        end
    end
end

其中A是一个包含一些标签的矩阵。我之前TFP以 N*N 稀疏双精度的形式存储。所以，我想出了以下解决方案，但我找不到一种方法来实现成员资格条件（由？指定）。

PID = sum(TFP).*(?);

可以不用循环实现吗？

y 是包含数字 1 到 10 的 5000 x 1 向量。我可以将 y 转换为 Y（5000 x 10 矩阵），使得

Y = zeros(5000,10);
for i = 1:5000
    Y(i,y(i))=1;
end

我可以在不使用 for 循环的情况下获得相同的结果吗？

我有一个整数数组：

[int1, int2, ..., intn]

我想计算这些整数的二进制表示中有多少非零位。

例如：

bin(123) -> 0b1111011, there are 6 non-zero bits

当然，我可以遍历整数、用途bin()和count('1')函数的列表，但我正在寻找矢量化的方法来做到这一点。

假设我有一个 2D numpy 数组，其值对应于一个标签或类。例如，如果 A = [[0, 0, 1, 1], [1, 1, 1, 0]，则位置(0, 0), (0, 1), (1, 3)对应于“0”(0, 2), (0, 3), (1, 0), etc类并对应于“1”类。这是一个非常简单的例子，但总的来说，我会处理包含更多项的矩阵。

我想要做的本质上是构建一个字典，其中一个键对应于每个类，其对应的值是一个元组列表，其中每个元组对应于输入矩阵的一个位置，其值为键。换句话说，按输入矩阵的值对输入矩阵进行分组，并获得每个唯一值出现的位置列表。

现在，我有以下代码：

S = {i: [] for i in range(A.max() + 1)}
for i in range(A.shape[0]):
    index = np.arange(A[i].shape[0])
    sort_idx = np.argsort(A[i])
    cnt = np.bincount(A[i])
    result = np.split(index[sort_idx], np.cumsum(cnt[:-1]))
    for j, k in enumerate(result):
        S[j] += [(i, z) for z in k]

其中 A 是我的输入矩阵。在 500x500 矩阵上运行平均需要大约 0.4 毫秒。尽管如此，我觉得它可以通过更好地利用矢量化（也许）来进一步改进。

有人可以指导我如何使其更简单和/或更快吗？任何帮助表示赞赏。谢谢！

我有一个 3d 位置向量数组 p [np.shape(p) yields (Nx, Ny, Nz, 3)] 和一个包含 n 个旋转矩阵的数组 Rn [np.shape(R) yields (n, 3, 3) ]。

我正在尝试获得一个形状为 (n, Nx, Ny, Nz, 3) 的数组 PR，其中第 i 个 (0 < i < n) 在维度 0 的条目是由 3x3 旋转旋转的位置向量 p 的 3d 数组数组 Rn 的索引 i 处的矩阵。

theta = np.arange(0, 2*np.pi, np.pi/50)
phi = np.arange(0, np.pi, np.pi/100)

a = np.arange(100)
b = np.arange(50)
p = np.array(np.meshgrid(a, b, a, indexing="xy"))
p = np.moveaxis(p, 1, 2)
p = np.moveaxis(p, 0, 3) …