4

我刚刚遇到了在 Python 中需要一个增量 Numpy 数组，因为我还没有找到任何东西，所以我实现了它。我只是想知道我的方法是否是最好的方法，或者您可以提出其他想法。

所以，问题是我有一个 2D 数组（程序处理 nD 数组），其大小事先不知道，并且需要在一个方向上将可变数量的数据连接到数组（假设我必须多次调用 np.vstak）。每次连接数据时，我都需要获取数组，沿轴 0 对其进行排序并执行其他操作，因此我无法构造一长串数组然后立即 np.vstak 列表。由于内存分配很昂贵，我转向增量数组，我将数组的大小增加一个大于我需要的大小的数量（我使用 50% 的增量），以便最小化分配的数量。

我对此进行了编码，您可以在以下代码中看到它：

class ExpandingArray:

    __DEFAULT_ALLOC_INIT_DIM = 10   # default initial dimension for all the axis is nothing is given by the user
    __DEFAULT_MAX_INCREMENT = 10    # default value in order to limit the increment of memory allocation

    __MAX_INCREMENT = []    # Max increment
    __ALLOC_DIMS = []       # Dimensions of the allocated np.array
    __DIMS = []             # Dimensions of the view with data on the allocated np.array (__DIMS <= __ALLOC_DIMS)

    __ARRAY = []            # Allocated array

    def __init__(self,initData,allocInitDim=None,dtype=np.float64,maxIncrement=None):
        self.__DIMS = np.array(initData.shape)

        self.__MAX_INCREMENT = maxIncrement
        if self.__MAX_INCREMENT == None:
            self.__MAX_INCREMENT = self.__DEFAULT_MAX_INCREMENT

        # Compute the allocation dimensions based on user's input
        if allocInitDim == None:
            allocInitDim = self.__DIMS.copy()

        while np.any( allocInitDim < self.__DIMS  ) or np.any(allocInitDim == 0):
            for i in range(len(self.__DIMS)):
                if allocInitDim[i] == 0:
                    allocInitDim[i] = self.__DEFAULT_ALLOC_INIT_DIM
                if allocInitDim[i] < self.__DIMS[i]:
                    allocInitDim[i] += min(allocInitDim[i]/2, self.__MAX_INCREMENT)

        # Allocate memory 
        self.__ALLOC_DIMS = allocInitDim
        self.__ARRAY = np.zeros(self.__ALLOC_DIMS,dtype=dtype)

        # Set initData 
        sliceIdxs = [slice(self.__DIMS[i]) for i in range(len(self.__DIMS))]
        self.__ARRAY[sliceIdxs] = initData

    def shape(self):
        return tuple(self.__DIMS)

    def getAllocArray(self):
        return self.__ARRAY

    def getDataArray(self):
        """
        Get the view of the array with data
        """
        sliceIdxs = [slice(self.__DIMS[i]) for i in range(len(self.__DIMS))]
        return self.__ARRAY[sliceIdxs]

    def concatenate(self,X,axis=0):
        if axis > len(self.__DIMS):
            print "Error: axis number exceed the number of dimensions"
            return

        # Check dimensions for remaining axis 
        for i in range(len(self.__DIMS)):
            if i != axis:
                if X.shape[i] != self.shape()[i]:
                    print "Error: Dimensions of the input array are not consistent in the axis %d" % i
                    return

        # Check whether allocated memory is enough 
        needAlloc = False
        while self.__ALLOC_DIMS[axis] < self.__DIMS[axis] + X.shape[axis]:
            needAlloc = True
            # Increase the __ALLOC_DIMS 
            self.__ALLOC_DIMS[axis] += min(self.__ALLOC_DIMS[axis]/2,self.__MAX_INCREMENT)

        # Reallocate memory and copy old data 
        if needAlloc:
            # Allocate 
            newArray = np.zeros(self.__ALLOC_DIMS)
            # Copy 
            sliceIdxs = [slice(self.__DIMS[i]) for i in range(len(self.__DIMS))]
            newArray[sliceIdxs] = self.__ARRAY[sliceIdxs]
            self.__ARRAY = newArray

        # Concatenate new data 
        sliceIdxs = []
        for i in range(len(self.__DIMS)):
            if i != axis:
                sliceIdxs.append(slice(self.__DIMS[i]))
            else:
                sliceIdxs.append(slice(self.__DIMS[i],self.__DIMS[i]+X.shape[i]))

        self.__ARRAY[sliceIdxs] = X
        self.__DIMS[axis] += X.shape[axis]

该代码显示出比 vstack/hstack 几个随机大小的串联要好得多的性能。

我想知道的是：这是最好的方法吗？在 numpy 中已经有什么可以做到这一点了吗？

此外，如果能够重载 np.array 的切片赋值运算符，那就太好了，这样一旦用户分配了实际尺寸之外的任何内容，就会执行 ExpandingArray.concatenate()。这种重载怎么办？

测试代码：我在这里也发布了一些我用来比较 vstack 和我的方法的代码。我将最大长度为 100 的随机数据块相加。

import time

N = 10000

def performEA(N):
    EA = ExpandingArray(np.zeros((0,2)),maxIncrement=1000)
    for i in range(N):
        nNew = np.random.random_integers(low=1,high=100,size=1)
        X = np.random.rand(nNew,2)
        EA.concatenate(X,axis=0)
        # Perform operations on EA.getDataArray()
    return EA

def performVStack(N):
    A = np.zeros((0,2))
    for i in range(N):
        nNew = np.random.random_integers(low=1,high=100,size=1)
        X = np.random.rand(nNew,2)
        A = np.vstack((A,X))
        # Perform operations on A
    return A

start_EA = time.clock()
EA = performEA(N)
stop_EA = time.clock()

start_VS = time.clock()
VS = performVStack(N)
stop_VS = time.clock()

print "Elapsed Time EA: %.2f" % (stop_EA-start_EA)
print "Elapsed Time VS: %.2f" % (stop_VS-start_VS)
4

2 回答 2

2

当我遇到类似的问题时，我使用了 ndarray.resize() ( http://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.resize.html#numpy.ndarray.resize )。大多数情况下，它将完全避免重新分配+复制。我不能保证它会被证明会更快（它可能会），但它要简单得多。

至于你的第二个问题，我认为为了扩展目的而覆盖切片分配不是一个好主意。该运算符用于分配给现有项目/切片。如果你想改变它，在某些情况下你希望它如何表现还不是很清楚，例如：

a = MyExtendableArray(np.arange(100))
a[200] = 6  # resize to 200? pad [100:200] with what?
a[90:110] = 7  # assign to existing items AND automagically-allocated items?
a[::-1][200] = 6 # ...

我的建议是切片分配和数据附加应该保持分开。

于 2013-02-22T15:36:13.457 回答
2

我认为这些东西最常见的设计模式是只为小数组使用一个列表。当然你可以做动态调整大小之类的事情（如果你想做一些疯狂的事情，你也可以尝试使用调整数组大小的方法）。我认为一个典型的方法是总是将大小加倍，当你真的不知道事情会有多大时。当然，如果您知道数组将增长到多大，那么预先分配完整的东西是最简单的。

def performVStack_fromlist(N):
    l = []
    for i in range(N):
        nNew = np.random.random_integers(low=1,high=100,size=1)
        X = np.random.rand(nNew,2)
        l.append(X)
    return np.vstack(l)

我确信在某些用例中扩展数组可能很有用（例如，当附加数组都非常小时），但使用上述模式似乎可以更好地处理这个循环。优化主要是关于您需要多久复制一次周围的所有内容，并且做一个这样的列表（除了列表本身），这恰好是一次。所以通常速度要快得多。

于 2013-02-22T15:18:24.433 回答