python - 通过沿轴应用 tuple() 沿轴挤压 ndarray

Question

给定 ndarray我想沿着一个轴挤压它，以便沿着该维度的元素将形成元组，即。 e.它将生成一个 ndarray维度比父元少一维的元组 ndarray .

假设我有一个如下所示的三维数组，它基本上是由 numpy.indices 生成的来自二维数组。

    idx = array([[[0, 0, 0, 0],
                  [1, 1, 1, 1],
                  [2, 2, 2, 2]],

                 [[0, 1, 2, 3],
                  [0, 1, 2, 3],
                  [0, 1, 2, 3]]])

我尝试使用numpy.apply_along_axis与 tuple() .

numpy.apply_along_axis(tuple, 0, idx)

它不起作用。因此，围绕 tuple() 创建了一个虚拟包装器并传递该函数来检查是否 tuple()是否按预期工作。

def dtuple(x):
    print(tuple(x))
    return tuple(x)

输出是:

(0, 0)
(0, 1)
(0, 2)
(0, 3)
(1, 0)
(1, 1)
(1, 2)
(1, 3)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
array([[[0, 0, 0, 0],
        [1, 1, 1, 1],
        [2, 2, 2, 2]],

       [[0, 1, 2, 3],
        [0, 1, 2, 3],
        [0, 1, 2, 3]]])

显然，tuple()工作正常，但奇怪的是，它没有返回 ndarray的tuple对象，而是返回相同的 ndarray 。我也尝试通过 idx.astype(object)而不仅仅是idx但这也不起作用。请注意，我试图避免 for在这里循环。预期输出如下:

array([[(0, 0), (0, 1), (0, 2), (0, 3)],
       [(1, 0), (1, 1), (1, 2), (1, 3)],
       [(2, 0), (2, 1), (2, 2), (2, 3)]], dtype=object)

Answer 1

让我们尝试一些替代方案:

In [563]: x=np.arange(12).reshape(3,4)                                                                 
In [564]: np.apply_along_axis(lambda i:[12],1,x)                                                       
Out[564]: 
array([[12],
       [12],
       [12]])
In [565]: np.apply_along_axis(lambda i:(1,2,3),1,x)                                                    
Out[565]: 
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])
In [566]: np.apply_along_axis(lambda i:i,1,x)                                                          
Out[566]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
In [567]: np.apply_along_axis(lambda i:i*2,1,x)                                                        
Out[567]: 
array([[ 0,  2,  4,  6],
       [ 8, 10, 12, 14],
       [16, 18, 20, 22]])

查看文档:

out : ndarray  (Ni..., Nj..., Nk...)
    The output array. The shape of `out` is identical to the shape of
    `arr`, except along the `axis` dimension. This axis is removed, and
    replaced with new dimensions equal to the shape of the return value
    of `func1d`. So if `func1d` returns a scalar `out` will have one
    fewer dimensions than `arr`.

无论函数返回的是数字、列表、元组还是数组，它仍然将其作为维度。 dtype 仍然是数字。

为什么要试图避免循环？ apply_along_axis 不会避免循环，它只是将其隐藏在函数中。

这是一个很好的循环:

In [578]: arr = np.empty(x.shape[0],object)                                                            
In [579]: for i,v in enumerate(x): 
     ...:     arr[i] = tuple(v.tolist()) 
     ...:                                                                                              
In [580]: arr                                                                                          
Out[580]: array([(0, 1, 2, 3), (4, 5, 6, 7), (8, 9, 10, 11)], dtype=object)

====

对于您的idx，有一种方法，通过结构化数组。这比我想要的要复杂一点，但现在是我的 sleep 时间了。

In [596]: arr = np.zeros((3,4),'i,i')                                                                  
In [597]: arr['f0']=idx[0]                                                                             
In [598]: arr['f1']=idx[1]                                                                             
In [599]: arr                                                                                          
Out[599]: 
array([[(0, 0), (0, 1), (0, 2), (0, 3)],
       [(1, 0), (1, 1), (1, 2), (1, 3)],
       [(2, 0), (2, 1), (2, 2), (2, 3)]],
      dtype=[('f0', '<i4'), ('f1', '<i4')])
In [600]: arr.tolist()                                                                                 
Out[600]: 
[[(0, 0), (0, 1), (0, 2), (0, 3)],
 [(1, 0), (1, 1), (1, 2), (1, 3)],
 [(2, 0), (2, 1), (2, 2), (2, 3)]]
In [601]: arr1=np.empty((3,4),object)                                                                  
In [602]: arr1[...] = _600                                                                             
In [603]: arr1                                                                                         
Out[603]: 
array([[(0, 0), (0, 1), (0, 2), (0, 3)],
       [(1, 0), (1, 1), (1, 2), (1, 3)],
       [(2, 0), (2, 1), (2, 2), (2, 3)]], dtype=object)