从 Numpy 矩阵构建 Python 集

Question

我正在尝试执行以下

>> from numpy import *
>> x = array([[3,2,3],[4,4,4]])
>> y = set(x)
TypeError: unhashable type: 'numpy.ndarray'

如何轻松有效地创建包含 Numpy 数组中所有元素的集合？

Answer 1

如果您想要一组元素，这里是另一种可能更快的方法：

y = set(x.flatten())

PS：在x.flat、x.flatten()<之间执行比较之后/code> 和 x.ravel() 在 10x100 数组上，我发现它们的执行速度大致相同。对于 3x3 数组，最快的版本是迭代器版本：

y = set(x.flat)

我推荐它，因为它是内存消耗较小的版本（它可以随着数组的大小很好地扩展）。

PPS：还有一个 NumPy 函数可以执行类似的操作：

y = numpy.unique(x)

这确实会生成一个与 set(x.flat) 具有相同元素的 NumPy 数组，但作为 NumPy 数组。这非常快（几乎快了 10 倍），但是如果您需要一个 set，那么执行 set(numpy.unique(x)) 会比其他方法慢一点程序（构建一套需要很大的开销）。

Answer 2

数组的不可变对应项是元组，因此，尝试将数组数组转换为元组数组：

>> from numpy import *
>> x = array([[3,2,3],[4,4,4]])

>> x_hashable = map(tuple, x)

>> y = set(x_hashable)
set([(3, 2, 3), (4, 4, 4)])

Answer 3

如果您想从 ndarray 中包含的元素创建一组，但如果您想创建一组 ndarray，则上述答案有效> 对象 – 或使用 ndarray 对象作为字典中的键 – 那么您必须为它们提供一个可散列的包装器。请参阅下面的代码作为一个简单的示例：

from hashlib import sha1

from numpy import all, array, uint8


class hashable(object):
    r'''Hashable wrapper for ndarray objects.

        Instances of ndarray are not hashable, meaning they cannot be added to
        sets, nor used as keys in dictionaries. This is by design - ndarray
        objects are mutable, and therefore cannot reliably implement the
        __hash__() method.

        The hashable class allows a way around this limitation. It implements
        the required methods for hashable objects in terms of an encapsulated
        ndarray object. This can be either a copied instance (which is safer)
        or the original object (which requires the user to be careful enough
        not to modify it).
    '''
    def __init__(self, wrapped, tight=False):
        r'''Creates a new hashable object encapsulating an ndarray.

            wrapped
                The wrapped ndarray.

            tight
                Optional. If True, a copy of the input ndaray is created.
                Defaults to False.
        '''
        self.__tight = tight
        self.__wrapped = array(wrapped) if tight else wrapped
        self.__hash = int(sha1(wrapped.view(uint8)).hexdigest(), 16)

    def __eq__(self, other):
        return all(self.__wrapped == other.__wrapped)

    def __hash__(self):
        return self.__hash

    def unwrap(self):
        r'''Returns the encapsulated ndarray.

            If the wrapper is "tight", a copy of the encapsulated ndarray is
            returned. Otherwise, the encapsulated ndarray itself is returned.
        '''
        if self.__tight:
            return array(self.__wrapped)

        return self.__wrapped

使用包装类非常简单：

>>> from numpy import arange

>>> a = arange(0, 1024)
>>> d = {}
>>> d[a] = 'foo'
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: unhashable type: 'numpy.ndarray'
>>> b = hashable(a)
>>> d[b] = 'bar'
>>> d[b]
'bar'

Answer 4

如果您想要一组元素：

>> y = set(e for r in x
             for e in r)
set([2, 3, 4])

对于一组行：

>> y = set(tuple(r) for r in x)
set([(3, 2, 3), (4, 4, 4)])

Answer 5

我喜欢 xperroni 的想法。但我认为可以使用从 ndarray 直接继承而不是包装它来简化实现。

from hashlib import sha1
from numpy import ndarray, array

class HashableNdarray(ndarray):
    @classmethod
    def create(cls, array):
        return HashableNdarray(shape=array.shape, dtype=array.dtype, buffer=array.copy())

    def __hash__(self):
        if not hasattr(self, '_HashableNdarray__hash'):
            self.__hash = int(sha1(self.view()).hexdigest(), 16)
        return self.__hash

    def __eq__(self, other):
        if not isinstance(other, HashableNdarray):
            return super().__eq__(other)
        return super().__eq__(super(HashableNdarray, other)).all()

NumPy ndarray 可以被视为派生类并用作可哈希对象。 view(ndarray) 可用于反向转换，但在大多数情况下甚至不需要它。

>>> a = array([1,2,3])
>>> b = array([2,3,4])
>>> c = array([1,2,3])
>>> s = set()

>>> s.add(a.view(HashableNdarray))
>>> s.add(b.view(HashableNdarray))
>>> s.add(c.view(HashableNdarray))
>>> print(s)
{HashableNdarray([2, 3, 4]), HashableNdarray([1, 2, 3])}
>>> d = next(iter(s))
>>> print(d == a)
[False False False]
>>> import ctypes
>>> print(d.ctypes.data_as(ctypes.POINTER(ctypes.c_double)))
<__main__.LP_c_double object at 0x7f99f4dbe488>

Answer 6

添加到@Eric Lebigot 和他的精彩帖子。

以下方法实现了构建张量查找表的技巧：

a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
np.unique(a, axis=0)

输出：

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

np.unique 文档