Numpy:与唯一坐标位置对应的值的平均值

时间:2015-08-07 12:54:16

标签: python arrays numpy

所以,我一直在浏览stackoverflow很长一段时间了,但我似乎找不到解决问题的方法

考虑一下

import numpy as np
coo = np.array([[1, 2], [2, 3], [3, 4], [3, 4], [1, 2], [5, 6], [1, 2]])
values = np.array([1, 2, 4, 2, 1, 6, 1])

coo数组包含(x,y)坐标位置 x =(1,2,3,3,1,5,1) y =(2,3,4,4,2,6,2)

并且值为此网格点排列某种数据。

现在我想获得每个唯一网格点的所有值的平均值。 例如,坐标(1,2)出现在位置(0,4,6),因此对于这一点,我想要values[[0, 4, 6]]

我如何才能获得所有独特网格点?

4 个答案:

答案 0 :(得分:4)

您可以使用np.lexsortcoo进行排序,以便重复使用# Use lexsort to bring duplicate coo XY's in succession sortidx = np.lexsort(coo.T) sorted_coo = coo[sortidx] # Get mask of start of each unique coo XY unqID_mask = np.append(True,np.any(np.diff(sorted_coo,axis=0),axis=1)) # Tag/ID each coo XY based on their uniqueness among others ID = unqID_mask.cumsum()-1 # Get unique coo XY's unq_coo = sorted_coo[unqID_mask] # Finally use bincount to get the summation of all coo within same IDs # and their counts and thus the average values average_values = np.bincount(ID,values[sortidx])/np.bincount(ID) 。然后沿着行运行np.diff以获得已排序版本中唯一XY的启动掩码。使用该掩码,您可以创建一个ID数组,该数组与重复项具有相同的ID。然后,ID数组可以与np.bincount一起使用,以获得具有相同ID的所有值的总和,以及它们的计数,从而得到平均值,作为最终输出。这是一个沿着这些方向实现的实现 -

In [65]: coo
Out[65]: 
array([[1, 2],
       [2, 3],
       [3, 4],
       [3, 4],
       [1, 2],
       [5, 6],
       [1, 2]])

In [66]: values
Out[66]: array([1, 2, 4, 2, 1, 6, 1])

In [67]: unq_coo
Out[67]: 
array([[1, 2],
       [2, 3],
       [3, 4],
       [5, 6]])

In [68]: average_values
Out[68]: array([ 1.,  2.,  3.,  6.])

示例运行 -

for (int i = 0; i<numberOfLevels; i += 1) {
    UIButton *btn = [UIButton buttonWithType:UIButtonTypeRoundedRect];
    [btn setTag:i];
    btn.frame = CGRectMake(midScreenX, midScreenY + separation*i, 100, 50);
    [btn setTitle:@"Hello, world!" forState:UIControlStateNormal];
    [btn addTarget:self action:@selector(buttonClicked:)forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:btn];
}



- (void)buttonClicked:(UIButton*)button
{
    NSLog(@"Button %ld clicked.", (long int)[button tag]);
}

答案 1 :(得分:2)

您可以使用where

>>> values[np.where((coo == [1, 2]).all(1))].mean()
1.0

答案 2 :(得分:1)

指数变平的可能性更快,即:

flat_index = coo[:, 0] * np.max(coo[:, 1]) + coo[:, 1]

然后在其上使用np.unique

unq, unq_idx, unq_inv, unq_cnt = np.unique(flat_index,
                                           return_index=True,
                                           return_inverse=True,
                                           return_counts=True)
unique_coo = coo[unq_idx]
unique_mean = np.bincount(unq_inv, values) / unq_cnt

比使用lexsort的类似方法。

但在幕后,这种方法实际上是一样的。

答案 3 :(得分:1)

这是一个简单的单行使用numpy_indexed包(免责声明:我是作者):

import numpy_indexed as npi
unique, mean = npi.group_by(coo).mean(values)

应该与当前接受的性能答案相媲美,因为它在引擎盖下做类似的事情;但是所有这些都在一个经过良好测试的包中,并且界面很好。