标签: array-broadcasting

我想将矩阵的每一列添加到 numpy 数组，但numpy.broadcast只允许将矩阵的每一行添加到数组。我怎样才能做到这一点？

我的想法是首先转置矩阵，然后将其添加到数组中，然后转置回来，但这使用了两次转置。有没有一个函数可以直接实现呢？

如果我有一个 2D numpy 数组，我想使用行、列索引对列表来提取元素。

xy = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
idx = np.array([[0, 0], [1, 1], [2, 2]])

for循环解决方案：

elements = list()
for i in idx:
    elements.append(xy[idx[i][0], xy[idx[i][1])

输出：

print(elements)
>> [1, 5, 9]

如果 idx 是元组列表，我找到了解决方案，但我希望找到一个不需要先将 idx 转换为元组的解决方案。

I have 2 dataframes:

>>> type(c)
Out[118]: pandas.core.frame.DataFrame
>>> type(N)
Out[119]: pandas.core.frame.DataFrame

>>> c
Out[114]: 
                       t
2017-06-01 01:06:00 1.00
2017-06-01 01:13:00 1.00
2017-06-01 02:09:00 1.00
2017-06-26 22:47:00 1.00

>>> N
Out[115]: 
                       0    1
2017-06-01 01:06:00 1.00 1.00
2017-06-01 01:13:00 1.00 1.00
2017-06-01 02:09:00 1.00 1.00
2017-06-26 22:47:00 1.00 1.00

我需要将它们相乘以获得 4,2 数据帧，该数据帧是将 N 的每一列与 C 元素相乘。我尝试了以下 4 种方法，但没有成功：

>>> N.multiply(c, axis='index')
Out[116]: 
                      0   1   t
2017-06-01 01:06:00 nan nan nan
2017-06-01 01:13:00 nan nan nan
2017-06-01 02:09:00 nan nan nan …

我有一个df_tr像这样的数据框：

      item_id    target   target_sum  target_count
0        0          0           1            50            
1        0          0           1            50              

我试图找到目标的平均值，但排除当前行的目标值，并将平均值放入新列中。结果将是：

     item_id    target   target_sum  target_count item_id_mean_target
0        0          0           1            50           0.02041
1        0          0           1            50           0.02041

我item_id_mean_target从公式计算值：

target_sum - target/target_count - 1

...用这个代码：

df_tr['item_id_mean_target'] = df_tr.target.apply(lambda x: (x['target_sum']-x)/(x['target_count']-1))     

我认为我的解决方案是正确的，但我得到了：

TypeError: 'float' object is not subscriptable                

我有一个 N 1x3 数组的 ndarray 我想与 3x3 矩阵执行点乘法。我似乎无法找到一种有效的方法来做到这一点，因为所有 multi_dot 和 tensordot 等方法似乎都是递归求和或乘以每个操作的结果。我只想像应用标量一样应用点乘法。我可以使用 for 循环或列表理解来完成此操作，但对于我的应用程序来说太慢了。

N = np.asarray([[1, 2, 3], [4, 5, 6], [7, 8, 9], ...])
m = np.asarray([[10, 20, 30], [40, 50, 60], [70, 80, 90]])

我想执行类似这样的操作，但没有任何 python 循环：

np.asarray([np.dot(m, a) for a in N])

这样它就简单地返回[m * N[0], m * N[1], m * N[2], ...]

最有效的方法是什么？有没有办法做到这一点，以便如果 N 只是一个 1x3 矩阵，它只会输出与 np.dot(m, N) 相同的结果？

例如，np.array([[1,2],[3,4]])[np.triu_indices(2)]具有 shape (3,)，是上三角条目的扁平列表。但是，如果我有一批 2x2 矩阵：

foo = np.repeat(np.array([[[1,2],[3,4]]]), 30, axis=0)

我想获得每个矩阵的上三角索引，最简单的尝试是：

foo[:,np.triu_indices(2)]

然而，这个对象实际上是有形状的（与我们批量提取上三角条目时所期望的相反）(30,2,3,2)。(30,3)

我们如何沿着批量维度广播元组索引？

假设我有一个xshape 的numpy 数组[1,5]。我想沿轴 0 扩展它，使得生成的数组y具有形状 [10,5] 并且对于每个 i 都y[i:i+1,:]等于x。

如果x是一个 pytorch 张量我可以简单地做

y = x.expand(10,-1)

但是 numpy 中没有expand，并且那些看起来像它（expand_dims和repeat）的行为似乎不像它。

例子：

y = x.expand(10,-1)

据我所知，在 Julia 中，大多数运算符都可以通过在其前面加上.. 然而我不明白为什么其中一些值得两种方式：

julia> a = rand(1_000_000);

julia> @time a*2;
  0.051112 seconds (183.93 k allocations: 17.849 MiB, 7.14% gc time, 89.16% compilation time)

julia> @time a*2;
  0.002070 seconds (2 allocations: 7.629 MiB)

julia> @time a.*2;
  0.026533 seconds (8.87 k allocations: 8.127 MiB, 93.23% compilation time)

julia> @time a.*2;
  0.001575 seconds (4 allocations: 7.630 MiB)

julia> a + 0.1;
ERROR: MethodError: no method matching +(::Vector{Float64}, ::Float64)

为什么数组广播对 有效*但无效+？

*是什么导致了和之间的性能/分配差异.*？

我们注意到，对于多维数组来说，花式索引和切片的混合使用非常令人困惑且没有记录，例如：

In [114]: x = np.arange(720).reshape((2,3,4,5,6))

In [115]: x[:,:,:,0,[0,1,2,4,5]].shape
Out[115]: (2, 3, 4, 5)

In [116]: x[:,:,0,:,[0,1,2,4,5]].shape
Out[116]: (5, 2, 3, 5)

我已经在https://numpy.org/doc/stable/user/basics.indexing.html上阅读了花哨索引的用法，我可以理解这一点x[:,0,:,[1,2]] = [x[:,0,:,1], x[:,0,:,2]]。但是我无法理解为什么上面的结果在第一个维度上Input [115]有所Input [116]不同。有人可以指出此类广播规则的记录在哪里吗？