Question

对不同大小的数组执行按元素操作而不对较小的数组进行过采样的最快，最方便的方法是什么？

例如：我有一个大数组，一个1000x1000，一个小数组B 10x10，我希望B中的每个元素都可以响应数组B中的100x100个元素。不需要任何插值，只需对B中的所有10000个操作使用B中的相同元素即可。答：

我可以调整两个数组的大小，以使A的形状是B的倍数。通常，它们在所有维度上均为1：10000或1：1000。阵列代表具有不同分辨率但程度相同的数据样本。

我知道我可以对数组B进行超采样，例如通过使用Kronecker产品，但是将数组B保持较小会更好，特别是因为我的某些数组变得非常大以至于可以处理和存储。我正在使用xarray和dask，但是任何numpy操作也可以使用。

我希望这个代码片段能够解释我的工作：

import numpy as np

A = np.random.rand(10,10)
B = np.random.rand(1000,1000)

res = np.shape(B)[0]//np.shape(A)[0]

#I want to add A and B so that each element in A is added to 100x100 elements in B.
#This doesn't work of obvious reasons:
#C = A+B

#This solution sacrifices the resolution of B:
C = A+B[::res,::res]

#These solutions creates an unnecessary large array for the operation(don't they?):
K = np.ones((res,res))
C = np.kron(A, K) + B

C = np.repeat(np.repeat(A,res, axis=0), res, axis=1)+B

我觉得这个问题一定是以前解决过的，但是我找不到适合该特定情况的任何答案。

Answer 1

我有一个类似的问题，最终解决了这个问题：

import numpy as np
import numba as nb
import time

@nb.jit(nb.void(nb.float64[:,:], nb.float64[:,:]), nopython=True, cache=True)
def func(A, B):
    # Assume different resolution along the different axes
    res_row = B.shape[0]//A.shape[0]
    res_col = B.shape[1]//A.shape[1]

    for i in range(A.shape[0]):
        for j in range(A.shape[1]):
            # Example to add, can be changed to any other function
            B[i * res_row : (i+1) * res_row, j * res_col : (j+1) * res_col] += A[i,j]


a = np.random.rand(1000,1000)
b = np.random.rand(10000,10000)

t1 = time.time()
func(a,b)
print("Time taken = {time_taken}".format(time_taken = time.time() - t1))
# with jitting on 8GB, 8 cores MacBook Pro = 0.45
# without jitting = 5.46

尽管，numba与该问题无关，但这是我采用的方法，使用JIT编译可显着提高性能。

Answer 2

通过广播，我们可以“复制”一小阵列，以处理更大的阵列。例如，如果

a = np.random.rand(10)
b = np.random.rand(1000).reshape(10,100)
a[:,None]+b

这里的技巧是将A的每个元素与B的（100,100）块配对。为此，我们需要重塑和转置。

In [3]: A = np.random.rand(10,10)
   ...: B = np.random.rand(1000,1000)
   ...: res = np.shape(B)[0]//np.shape(A)[0]

您的目标：

In [4]: K = np.ones((res,res))
   ...: C = np.kron(A, K) + B
   ...: 
   ...: C = np.repeat(np.repeat(A,res, axis=0), res, axis=1)+B

In [5]: C.shape
Out[5]: (1000, 1000)

将B分成以下（100,100）个块：

In [7]: B1 = B.reshape(10,100,10,100).transpose(0,2,1,3)

In [8]: B1.shape
Out[8]: (10, 10, 100, 100)

现在我们可以添加广播

In [9]: C1 = B1 + A[:,:,None,None]

In [10]: C1.shape
Out[10]: (10, 10, 100, 100)

重塑为原始的B形状：

In [11]: C1=C1.transpose(0,2,1,3).reshape(B.shape)

它们匹配：

In [12]: np.allclose(C,C1)
Out[12]: True

不同大小的数组的按元素操作

2 个答案: