有效地查找 2D numpy 数组中正值的索引范围

Question

我有一个大的 numpy 数组（通常为 500,000x1024，但可以更大），我正在尝试执行几个过程，这些过程取决于数组中正值的位置。 一个非常小的示例数组可能是

  [[ 0., 0., 0., 0., 0.,-1.,-1., 0., 0.],
   [ 0., 0., 0., 0., 0., 0., 0., 0., 0.],
   [ 0., 1., 1., 0., 0., 1., 5., 0., 0.],
   [ 0., 1., 1., 0., 0., 0., 1., 0., 0.],
   [ 0., 3., 1., 0., 0., 2., 1., 0., 0.],
   [ 0., 0., 0., 0., 0., 0., 0., 0., 0.],
   [ 0., 1., 0., 0., 0., 1., 1., 0., 0.],
   [ 0., 0., 0., 0., 0., 0., 0., 0., 0.]]

第一个是替换每行中相距小于三列的正值之间的任何零。所以如果我用 50 替换这些数字，我的示例输出将是

 [[ 0., 0., 0., 0., 0.,-1.,-1., 0., 0.],
  [ 0., 0., 0., 0., 0., 0., 0., 0., 0.],
  [ 0., 1., 1.,50.,50., 1., 5., 0., 0.],
  [ 0., 1., 1., 0., 0., 0., 1., 0., 0.],
  [ 0., 3., 1.,50.,50., 2., 1., 0., 0.],
  [ 0., 0., 0., 0., 0., 0., 0., 0., 0.],
  [ 0., 1., 0., 0., 0., 1., 1., 0., 0.],
  [ 0., 0., 0., 0., 0., 0., 0., 0., 0.]]

我需要做的第二件事是根据正值的范围为每一行写出一些信息。例如，使用我更改的数组，我需要能够为第三行写出一条语句，为 col[1:7] 声明正整数，为第四行写两条语句，在 col[1:3] 和 col 中声明正整数[6]。

我已经设法利用 numpy 向量化方法来解决第一个任务，但最终还是求助于循环遍历列和行（尽管在整个数组的子集上）。否则，我最终会替换给定行中的所有零，而不仅仅是正值之间的零。

但第二个任务我似乎找不到不使用循环遍历整个数组的方法

for col in arr:
  for row in arr:

我想我的总体问题是，有没有办法利用 numpy 中的矢量化方法来定义每行不同的列索引范围并取决于以下列中的值？

任何帮助将不胜感激。

Answer 1

不幸的是，Numpy 不能在不生成更多数组的情况下进行大量处理，所以我担心任何解决方案都需要像您一直在使用的某种形式的手动循环，或者创建一个或多个额外的大数组。您可以使用 numexpr 提出一个非常快速且内存高效的解决方案。

这里有一个尝试这样做的方式不一定是内存效率，但至少所有循环都将由 Numpy 完成，所以应该比你一直在做的要快得多，只要它适合在你的记忆中。 （通过将其中的一些重写为就地操作可能会提高内存效率，但我不会担心。）

这是您的第 1 步：

positive = x>0 # a boolean array marking the positive values in x

positive0 = positive[:,0:-3] # all but last 3 columns 
positive1 = positive[:,1:-2] # all but 1st and last 2 columns; not actually used
positive2 = positive[:,2:-1] # all but first 2 and last 1 columns
positive3 = positive[:,3:  ] # all but first 3 columns

# In the following, the suffix 1 indicates that we're viewing things from the perspective
# of entries in positive1 above.  So, e.g., has_pos_1_to_left1 will be True at
# any position where an entry in positive1 would be preceded by a positive entry in x

has_pos_1_to_left1 = positive0
has_pos_1_or_2_to_right1 = positive2 | positive3
flanked_by_positives1 = has_pos_1_to_left1 & has_pos_1_or_2_to_right1

zeros = (x == 0)       # indicates everywhere x is 0
zeros1 = zeros[:,1:-2] # all but 1st and last 2 columns

x1 = x[:,1:-2]         # all but 1st and last 2 columns

x1[zeros1 & flanked_by_positives1] = 50 # fill in zeros that were flanked - overwrites x!

# The preceding didn't address the next to last column, b/c we couldn't
# look two slots to the right of it without causing error.  Needs special treatment:
x[:,-2][ zeros[:,-2] & positive[:,-1] & (positive[:,-4] or positive[:,-3])] = 50

这是您的第 2 步：

filled_positives = x>0 # assuming we just filled in x
diffs = numpy.diff(filled_positives) # will be 1 at first positive in any sequence,
                                     # -1 after last positive, zero elsewhere

endings = numpy.where(diffs==-1) # tuple specifying coords where positive sequences end 
                                 # omits final column!!!
beginnings = numpy.where(diffs==1) # tuple specifying coords where pos seqs about to start
                                   # omits column #0!!!

使用这些开始和结束坐标来提取您说需要的每一行的信息应该很简单，但请记住，这种差异检测方法仅捕获从非肯定到肯定的转换 ，反之亦然，因此它不会提及从第零列开始或在最后一列结束的正序列，因此如果需要，您需要单独查找这些非转换。

Answer 2

您可以使用高效的 numpy 迭代器，例如 flatiter 或 nditer

例如，对于您的第二个任务

In [1]: x = array([[ 0., 0., 0., 0., 0.,-1.,-1., 0., 0.],
   ...:            [ 0., 0., 0., 0., 0., 0., 0., 0., 0.],
   ...:            [ 0., 1., 1.,50.,50., 1., 5., 0., 0.],
   ...:            [ 0., 1., 1., 0., 0., 0., 1., 0., 0.],
   ...:            [ 0., 3., 1.,50.,50., 2., 1., 0., 0.],
   ...:            [ 0., 0., 0., 0., 0., 0., 0., 0., 0.],
   ...:            [ 0., 1., 0., 0., 0., 1., 1., 0., 0.],
   ...:            [ 0., 0., 0., 0., 0., 0., 0., 0., 0.]])

In [2]: islands = []
   ...: fl = x.flat
   ...: while fl.index < x.size:
   ...:     coord = fl.coords
   ...:     if fl.next() > 0:
   ...:         length = 1
   ...:         while fl.next() > 0:
   ...:             length +=1
   ...:         islands.append([coord, length])

In [3]: for (row, col), length in islands:
   ...:     print 'row:%d ; col[%d:%d]' %(row, col, col+length)
row:2 ; col[1:7]
row:3 ; col[1:3]
row:3 ; col[6:7]
row:4 ; col[1:7]
row:6 ; col[1:2]
row:6 ; col[5:7]

Answer 3

对于你的第一个问题：创建一个变量来保存你遇到的第一个正数的索引，并有一个 if 语句在下一个值为正数时重置位置并且计数（变量从第一个正数算起的位置）小于 3。

第二个问题：创建一个数组并添加正值位置的索引。

 String[] indices = new String[];
 int pos = 0;
 for col in arr:
     for row in arr:
        if(index is positive){
             indices[pos] = "[" + col + ":" + row + "]";
             pos++;
         }

Answer 4

第二种方法是让数据创建对象，所以假设你有一个类：

public class Matrix{
   int indicex;
   int indicey;
   double val;
   boolean positiveInt;

   //default constructor
   public Matrix(int indicex, int indicey, double val, boolean positiveInt){
   this.indicex = indicex;
   this.indicey = indicey;
   this.val = val;
   this.positiveInt = positiveInt;
   }    

   //getter
   public boolean isPositive(){
        if(positiveInt == true){
              return true;
        }else{
            return false;
        }

然后在您的驱动程序类中，您将读取数据并创建一个对象 new Matrix(indexx, indexy, val, true/false)...。然后将其放入您可以搜索的数组列表中为正数。

List<Matrix> storeObjects = new ArrayList<Matrix>();
some method(){
   Matrix matrixObject = new Matrix(indexx, indexy, val, trueOrFalse);
   storeObjects.add(matrixObject)
 }

 for every object in store objects 
    if(object.isPositive()){
         put object in a separate array of positive objects
     }
  }