Python 在Numpy 4d阵列中沿轴获取唯一值

给定如下所示的数组（表示具有3行19个RGB像素的图像）：

test_nested_array = np.array([[[
       [  6.,  11.,  14.],
       [  6.,  11.,  14.],
       [  6.,  11.,  14.],
       [  6.,  11.,  14.],
       [  7.,  12.,  15.],
       [  7.,  12.,  15.],
       [  7.,  12.,  15.],
       [  7.,  12.,  15.],
       [  7.,  15.,  18.],
       [  7.,  15.,  18.],
       [  8.,  13.,  16.],
       [  8.,  13.,  16.],
       [  8.,  13.,  17.],
       [  8.,  16.,  19.],
       [  8.,  16.,  19.],
       [  8.,  16.,  19.],
       [ 10.,  15.,  18.],
       [ 10.,  18.,  21.],
       [ 15.,  24.,  29.]],

       [[  15.,  11.,  14.],
       [  13.,  11.,  14.],
       [  15.,  11.,  14.],
       [  11.,  11.,  14.],
       [  7.,  19.,  15.],
       [  7.,  12.,  15.],
       [  7.,  12.,  15.],
       [  7.,  12.,  15.],
       [  7.,  17.,  18.],
       [  7.,  17.,  18.],
       [  8.,  13.,  16.],
       [  8.,  13.,  16.],
       [  8.,  13.,  17.],
       [  8.,  16.,  19.],
       [  8.,  16.,  19.],
       [  8.,  16.,  19.],
       [ 10.,  15.,  18.],
       [ 10.,  18.,  21.],
       [ 15.,  24.,  29.]],

       [[  6.,  11.,  14.],
       [  6.,  11.,  14.],
       [  6.,  11.,  14.],
       [  6.,  11.,  14.],
       [  7.,  12.,  15.],
       [  7.,  12.,  15.],
       [  7.,  12.,  15.],
       [  7.,  12.,  15.],
       [  7.,  15.,  18.],
       [  7.,  15.,  18.],
       [  8.,  13.,  16.],
       [  8.,  13.,  16.],
       [  8.,  13.,  17.],
       [  8.,  16.,  19.],
       [  8.,  16.,  19.],
       [  8.,  16.,  19.],
       [ 10.,  15.,  18.],
       [ 10.,  18.,  21.],
       [ 15.,  24.,  29.]]
]])

使用

（1,3,19,3）

形状，我希望检索每行中唯一像素的集合作为新的子数组。所以，本质上，我想在每一行19个像素上做一个

np.unique

。如果我单独做，一切都会顺利：

np.unique(test_nested_array.squeeze(0)[0], axis=0)

>>> array([[ 6., 11., 14.],
           [ 7., 12., 15.],
           [ 7., 15., 18.],
           [ 8., 13., 16.],
           [ 8., 13., 17.],
           [ 8., 16., 19.],
           [10., 15., 18.],
           [10., 18., 21.],
           [15., 24., 29.]])

但是，我希望在所有行上执行此操作以提高速度，并且我认为可以为

np.unique

调用提供

axis=2

参数，因此该函数是通过行计算的。但是，这并不能提供正确的输出：

np.unique(test_nested_array, axis=2)

>>> array([[[[ 6., 11., 14.],
         [ 6., 11., 14.],
         [ 6., 11., 14.],
         [ 7., 12., 15.],
         [ 7., 12., 15.],
         [ 7., 15., 18.],
         [ 8., 13., 16.],
         [ 8., 13., 17.],
         [ 8., 16., 19.],
         [10., 15., 18.],
         [10., 18., 21.],
         [15., 24., 29.]],

        [[11., 11., 14.],
         [13., 11., 14.],
         [15., 11., 14.],
         [ 7., 12., 15.],
         [ 7., 19., 15.],
         [ 7., 17., 18.],
         [ 8., 13., 16.],
         [ 8., 13., 17.],
         [ 8., 16., 19.],
         [10., 15., 18.],
         [10., 18., 21.],
         [15., 24., 29.]],

        [[ 6., 11., 14.],
         [ 6., 11., 14.],
         [ 6., 11., 14.],
         [ 7., 12., 15.],
         [ 7., 12., 15.],
         [ 7., 15., 18.],
         [ 8., 13., 16.],
         [ 8., 13., 17.],
         [ 8., 16., 19.],
         [10., 15., 18.],
         [10., 18., 21.],
         [15., 24., 29.]]]])

这个输出对我来说很奇怪，因为第二种数组似乎是重复数据消除的，但没有按照文档进行排序，而第一个和第三个数组根本没有重复数据消除

我还尝试通过在轴之间执行

apply\u

来获得结果，但出现了错误：

np.apply_along_axis(np.unique, 2, test_nested_array)

>>> ValueError: could not broadcast input array from shape (7) into shape (5)

我没有真正理解这里的

（7）

和

（5）

，所以还是不知道。我的假设是，因为

np.unique

试图将重复数据消除的子阵列放入一个阵列中，但由于重复数据消除的子阵列可以有不同的形状，所以失败了，但我不确定以高效、快速的方式实现这一点的最佳方法是什么

---

提前多谢

尽管@Divakar的提示对我有进一步的帮助，但我最终还是使用

numpy\u index

包来提取如下唯一条目：

import numpy_indexed as npi
uniq = npi.unique(data)

---

这对于我的用例来说要快得多。

尽管@Divakar的提示对我有进一步的帮助，但我最终还是使用

numpy\u index

包来提取这样的唯一条目：

import numpy_indexed as npi
uniq = npi.unique(data)

---

对于我的用例来说，这要快得多。

对于范围（3）内的i，

[np.unique（test\u nested\u array.squence（0）[i]，axis=0）]

是否捕获了您想要的o/p？最终预期o/p的形状是什么？是的，它确实捕获了它。我可以这样做，但这是最好/最有效的方式吗？这个形状将是（3），因为子数组的大小当然可能不同。考虑到每个“19像素行”可能有不同数量的唯一行，这似乎是我们能得到的最好结果。对于范围（3）中的i，是否

[np.unique（test\u nested\u array.squence（0）[i]，axis=0）]

捕获您想要的o/p？最终预期o/p的形状是什么？是的，它确实捕获了它。我可以这样做，但这是最好/最有效的方式吗？这个形状将是（3），因为子数组的大小当然可能不同。考虑到每个“19像素行”可能有不同数量的唯一行，这似乎是我们能得到的最好结果。