午夜过后，也许有人知道如何解决我的问题。我想将相邻单元格的数量（这意味着具有其他值的数组字段的数量，例如数组值附近的零）作为 每个有效值的 总和
！ 。

例：

import numpy,scipy
s = ndimage.generate_binary_structure(2,2) # Structure can vary
a = numpy.zeros((6,6),dtype=numpy.int) # Example array
a[2:4,2:4] = 1;a[2,4] = 1 # with example value structure
print a 
>[[0 0 0 0 0 0]
  [0 0 0 0 0 0]
  [0 0 1 1 1 0]
  [0 0 1 1 0 0]
  [0 0 0 0 0 0]
  [0 0 0 0 0 0]]
# The value at position [2,4] is surrounded by 6 zeros,while the one at
# position [2,2] has 5 zeros in the vicinity if 's' is the assumed binary structure. 
# Total sum of surrounding zeroes is therefore sum(5+4+6+4+5) == 24

如果我的值的结构变化，我如何以这种方式计算零的数量？我以某种方式认为必须使用SciPy的binary_dilation函数，该函数能够扩大值结构，但是对重叠的简单计数不能使我得出正确的总和？

print ndimage.binary_dilation(a,s).astype(a.dtype)
[[0 0 0 0 0 0]
 [0 1 1 1 1 1]
 [0 1 1 1 1 1]
 [0 1 1 1 1 1]
 [0 1 1 1 1 0]
 [0 0 0 0 0 0]]

我有两个数组,例如形状(3,2)和另一个形状(10,7).我想要两个数组的所有组合,这样我最终得到一个9列数组.换句话说,我希望第一个数组的每一行的所有组合与第二个数组的行.

我怎样才能做到这一点？据我所知,我没有正确使用meshgrid.

根据以前的帖子,我的印象是

a1 = np.zeros((10,7))
a2 = np.zeros((3,2))
r = np.array(np.meshgrid(a1,a2)).T.reshape(-1,a1.shape[1] + a2.shape[1])

会工作,但这给我的尺寸(84,10).

关注性能这里的一种方法是使用数组初始化和元素广播进行分配 –

m1,n1 = a1.shape
m2,n2 = a2.shape
out = np.zeros((m1,m2,n1+n2),dtype=int)
out[:,:,:n1] = a1[:,None,:]
out[:,n1:] = a2
out.shape = (m1*m2,-1)

说明：

诀窍在于两个步骤：

out[:,n1:] = a2

步骤1 ：

In [227]: np.random.seed(0)

In [228]: a1 = np.random.randint(1,9,(3,2))

In [229]: a2 = np.random.randint(1,(2,7))

In [230]: m1,n1 = a1.shape
     ...: m2,n2 = a2.shape
     ...: out = np.zeros((m1,dtype=int)
     ...: 

In [231]: out[:,:]

In [232]: out[:,:n1]
Out[232]: 
array([[[5,8],[5,8]],[[6,1],[6,1]],[[4,4],[4,4]]])

In [233]: a1[:,:]
Out[233]: 
array([[[5,4]]])

因此,基本上我们分配a1的元素,保持第一轴与输出中相应的一个轴对齐,同时让输出数组的第二轴上的元素以广播的方式填充,对应于为a1添加的newaxis那个轴.这是关键所在并带来性能,因为我们没有分配额外的内存空间,否则我们需要使用显式的重复/平铺方法.

第2步 ：

In [237]: out[:,n1:] = a2

In [238]: out[:,n1:]
Out[238]: 
array([[[4,8,2,4,6,3,5],[8,7,1,5,2]],2]]])

In [239]: a2
Out[239]: 
array([[4,2]])

这里,我们基本上沿着输出数组的第一轴广播块a2而不明确地重复复制.

样本输入,输出完整性 –

In [242]: a1
Out[242]: 
array([[5,4]])

In [243]: a2
Out[243]: 
array([[4,2]])

In [244]: out
Out[244]: 
array([[[5,2]]])

方法#2

另一个有平铺/重复 –

parte1 = np.repeat(a1[:,:],axis=0).reshape(-1,m2)
parte2 = np.repeat(a2[None],m1,n2)
out = np.c_[parte1,parte2] 

5 12 14 200   0 45223
7 12 14   0 200 60000
7  6 23   0   0 45223
5  6 14 200   0 45223

0 2 2 4
2 0 2 1
2 2 0 3
4 1 3 0

0 1 2
0 2 2
0 3 4
1 2 2 
1 3 1
2 3 3

import itertools
import numpy as np

def pairwise_identical_elements(small_matrix):
    n,p = small_matrix.shape
    coordinates = itertools.combinations(range(n),2)
    sparse_coordinate_matrix = []
    for row1,row2 in itertools.combinations(small_matrix,2):
        idx1,idx2 = next(coordinates)
        count = p - np.count_nonzero(row1 - row2)
        sparse_coordinate_matrix.append([idx1,idx2,count])
    return sparse_coordinate_matrix

解决方法