标签: numpy-einsum

来自这个问题,我想知道是否有更广泛的einsum是可能的.让我们假设,我遇到了问题

using PyCall
@pyimport numpy as np

a = rand(10,10,10)
b = rand(10,10)
c = rand(10,10,10)

Q = np.einsum("imk,ml,lkj->ij", a,b,c)

或类似的东西,我怎么解决这个问题而不循环总和？

最诚挚的问候

我有四个张量

1. H(h,r)
2. A(a,r)
3. D(d,r)
4. T(a,t,r)

对于每个iin a,都有相应T[i]的形状(t, r).

我需要做一个np.einsum来产生以下结果(pred):

pred = np.einsum('hr, ar, dr, tr ->hadt', H, A, D, T[0])
for i in range(a):
    pred[:, i:i+1, :, :] = np.einsum('hr, ar, dr, tr ->HADT', H, A[i:i+1], D, T[i])

但是,我想在不使用for循环的情况下进行此计算.原因是我autograd正在使用哪个目前不适用于项目分配!

我有以下张量执行，

np.einsum('k,pjqk,yzjqk,yzk,ipqt->it', A, B, C, D, E)

我注意到，当“z”或“q”维度扩展时，执行时间确实受到了影响，尽管我的直觉是它可能不应该那么糟糕 - 也许这是我的输入形式，我可以通过手动张量收缩来优化。

经过一番挖掘后，我发现优化有两种模式：“最优”和“贪婪”。如果我根据两种模式评估我的路径，我分别有：

(['einsum_path', (0, 3), (1, 3), (0, 2), (0, 1)],
'  Complete contraction:  k,pjqk,yzjqk,yzk,ipqt->it\n'
'         Naive scaling:  8\n'
'     Optimized scaling:  5\n'
'      Naive FLOP count:  5.530e+04\n'
'  Optimized FLOP count:  7.930e+02\n'
'   Theoretical speedup:  69.730\n'
'  Largest intermediate:  2.400e+01 elements\n'
'--------------------------------------------------------------------------\n'
'scaling                  current                                remaining\n'
'--------------------------------------------------------------------------\n'
'   3                  yzk,k->yzk                  pjqk,yzjqk,ipqt,yzk->it\n'
'   5              yzk,yzjqk->jqk                        pjqk,ipqt,jqk->it\n'
'   4                jqk,pjqk->qp                              ipqt,qp->it\n'
'   4                 qp,ipqt->it                                   it->it')

和

(['einsum_path', (2, 3), (1, 3), (1, 2), …

如果我将一个向量x(1,n)与它自身相乘,即np.dot(x.T, x)我将获得二次形式的矩阵.

如果我有一个矩阵Xmat(k,n),我怎样才能有效地计算行方点积并只选择上三角形元素？

所以,atm.我有以下解决方案:

def compute_interaction(x):
    xx = np.reshape(x, (1, x.size))
    return np.concatenate((x, np.dot(xx.T, xx)[np.triu_indices(xx.size)]))

然后compute_interaction(np.asarray([2,5]))屈服array([ 2, 5, 4, 10, 25]).

当我有一个矩阵我用

np.apply_along_axis(compute_interaction, axis=1, arr = np.asarray([[2,5], [3,4], [8,9]]))

产生我想要的东西:

array([[ 2,  5,  4, 10, 25],
       [ 3,  4,  9, 12, 16],
       [ 8,  9, 64, 72, 81]])

有没有其他方法来计算这个使用apply_along_axis？也许用np.einsum？

我试图从这个矩阵乘法中删除循环（并了解更多关于一般优化代码的信息），我想我需要某种形式的np.broadcastingor np.einsum，但是在阅读它们之后，我仍然不确定如何使用它们我的问题。

A = np.array([[1, 2, 3, 4, 5],
         [6, 7, 8, 9, 10],
         [11,12,13,14,15]])
#A is a 3x5 matrix, such that the shape of A is (3, 5) (and A[0] is (5,))

B = np.array([[1,0,0],
         [0,2,0],
         [0,0,3]])
#B is a 3x3 (diagonal) matrix, with a shape of (3, 3)

C = np.zeros(5)
for i in range(5):
    C[i] = np.linalg.multi_dot([A[:,i].T, B, A[:,i]])

#Each row of matrix math is [1x3]*[3x3]*[3x1] to become a scaler value in each row …

我熟悉einsumNumPy中的工作方式。PyTorch也提供了类似的功能：torch.einsum（）。在功能或性能上有何异同？PyTorch文档中提供的信息很少，并且没有提供有关此方面的任何见解。

假设我们在下面有一个一维数组

arr = np.array([a,b,c])

我需要做的第一件事是制作所有元素的产品，即

[ab,ac,bc]

然后用这个元素构造一个二维三角形数组

[
[a,ab,ac],
[0,b,bc],
[0,0,c]
]

假设我有项目和一个代表这些项目包含在结果中的N多热值向量：{0, 1}

N = 4

# items 1 and 3 will be included in the result
vector = [0, 1, 0, 1]

# item 2 will be included in the result
vector = [0, 0, 1, 0]

我还提供了一个冲突矩阵，指示哪些项目不能同时包含在结果中：

conflicts = [
  [0, 1, 1, 0], # any result that contains items 1 AND 2 is invalid
  [0, 1, 1, 1], # any result that contains AT LEAST 2 items from {1, 2, 3} is invalid
]

给定这个冲突矩阵，我们可以确定早期 …

我想将以下 numpy einsum 编写为特征张量操作

import numpy as np

L = np.random.rand(2, 2, 136)
U = np.random.rand(2, 2, 136)

result = np.einsum('ijl,jkl->ikl', U, L)

我可以像 C++ 中那样用 for 循环编写它

  for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 2; j++) {
      for (int k = 0; k < 2; k++) {
        for (int l = 0; l < 136; l++) {
          result(i, k, l) += U(i, j, l) * L(j, k, l);
        } …

让A是一个(N,M,M)矩阵（N非常大），我想计算scipy.linalg.expm(A[n,:,:])每个n in range(N)。我当然可以只使用for循环，但我想知道是否有一些技巧可以以更好的方式做到这一点（例如np.einsum）。

我对矩阵求逆等其他操作也有同样的问题（在评论中解决了求逆问题）。