Question

每当我需要测试一个中等复杂的numpy表达式时，比方说，

c = np.multiply.outer(a, b)
d = np.einsum('kjij->ijk', c)

我最终会采取行动，例如设置a和b

a = np.arange(9).reshape(3,3)
b = a / 10

以便我可以跟踪d包含的内容。

这很难看，不太方便。理想情况下，我可以做以下事情：

a = np.array(list("abcdefghi")).reshape(3,3)
b = np.array(list("ABCDEFGHI")).reshape(3,3)

c = np.add.outer(a, b)
d = np.einsum('kjij->ijk', c)

因此，例如，d[0, 1, 2]可以看作对应于＆＃39; hB＆＃39;，这比.7更清晰（这是a和{b的另一项任务。 {1}}会给。）这是无法做到的，因为ufunc add不会占用字符。

总之，一旦我开始链接一些变换（外部产品，einsum，广播或切片等），我就会失去踪迹，需要亲眼看看我的变换实际上在做什么。当我需要运行一些例子时，我现在这样做的方式让我觉得不够理想。是否有任何标准或更好的方法来做到这一点？

Answer 1

In [454]: a = np.array(list("abcdefghi")).reshape(3,3)
     ...: b = np.array(list("ABCDEFGHI")).reshape(3,3)

np.add无法使用，因为尚未为字符串add定义dtype：

In [455]: c = np.add.outer(a,b)
....
TypeError: ufunc 'add' did not contain a loop with signature matching types dtype('<U1') dtype('<U1') dtype('<U1')

但是np.char具有将string方法应用于ndarray元素的功能（这些方法不快，只是方便）：

Signature: np.char.add(x1, x2)
Docstring:
Return element-wise string concatenation for two arrays of str or unicode.

使用广播我可以执行outer字符串连接：

In [457]: c = np.char.add(a[:,:,None,None], b[None,None,:,:])
In [458]: c.shape
Out[458]: (3, 3, 3, 3)
In [459]: c
Out[459]: 
array([[[['aA', 'aB', 'aC'],
         ['aD', 'aE', 'aF'],
         ['aG', 'aH', 'aI']],

        [['bA', 'bB', 'bC'],
         ['bD', 'bE', 'bF'],
         ['bG', 'bH', 'bI']],

        ....
        [['iA', 'iB', 'iC'],
         ['iD', 'iE', 'iF'],
         ['iG', 'iH', 'iI']]]], dtype='<U2')

我怀疑einsum可以处理此数组，因为通常einsum用于np.dot，就像产品总和计算一样。但是通过这种索引，它只是选择对角线和重新排列轴，所以它确实有效：

In [460]: np.einsum('kjij->ijk', c)
Out[460]: 
array([[['aA', 'dA', 'gA'],
        ['bB', 'eB', 'hB'],
        ['cC', 'fC', 'iC']],

       [['aD', 'dD', 'gD'],
        ['bE', 'eE', 'hE'],
        ['cF', 'fF', 'iF']],

       [['aG', 'dG', 'gG'],
        ['bH', 'eH', 'hH'],
        ['cI', 'fI', 'iI']]], dtype='<U2')

数字测试用例中的d：

array([[[0. , 3. , 6. ],
        [1.1, 4.1, 7.1],
        [2.2, 5.2, 8.2]],

       [[0.3, 3.3, 6.3],
        [1.4, 4.4, 7.4],
        [2.5, 5.5, 8.5]],

       [[0.6, 3.6, 6.6],
        [1.7, 4.7, 7.7],
        [2.8, 5.8, 8.8]]])

具有这些数值的模式与字符串一样清晰。

我喜欢在可能的情况下使用不同的数组形状，因为它可以更轻松地跟踪更改的跟踪维度：

In [496]: a3 = np.arange(1,13).reshape(4,3)
     ...: b3 = np.arange(1,7).reshape(2,3) / 10
In [497]: c3 = np.add.outer(a3,b3)
In [498]: d3 = np.einsum('kjij->ijk', c3)
In [499]: c3.shape
Out[499]: (4, 3, 2, 3)
In [500]: d3.shape
Out[500]: (2, 3, 4)
In [501]: d3
Out[501]: 
array([[[ 1.1,  4.1,  7.1, 10.1],
        [ 2.2,  5.2,  8.2, 11.2],
        [ 3.3,  6.3,  9.3, 12.3]],

       [[ 1.4,  4.4,  7.4, 10.4],
        [ 2.5,  5.5,  8.5, 11.5],
        [ 3.6,  6.6,  9.6, 12.6]]])

例如，如果我尝试＆＃39; kjik-＆gt; ijk＆＃39;这会引发错误。

使用数值我可以使用multiply.outer执行einsum：

In [502]: c4 = np.multiply.outer(a3,b3)
In [503]: np.allclose(c4,np.einsum('ij,kl',a3,b3))
Out[503]: True
In [504]: d4 = np.einsum('kjij->ijk', c4)
In [505]: np.allclose(d4,np.einsum('kj,ij->ijk',a3,b3))
Out[505]: True
In [506]: d4
Out[506]: 
array([[[0.1, 0.4, 0.7, 1. ],
        [0.4, 1. , 1.6, 2.2],
        [0.9, 1.8, 2.7, 3.6]],

       [[0.4, 1.6, 2.8, 4. ],
        [1. , 2.5, 4. , 5.5],
        [1.8, 3.6, 5.4, 7.2]]])

'kj,ij->ijk'让我比d显示更了解所发生的事情。

另一种说法：

(4,3) + (2,3) => (2,3,4)

测试Numpy操作

1 个答案: