Wie entferne ich führende maskierte Elemente in einem Numpy-Array?

Question

So entfernen Sie führende maskierte Elemente aus einem Numpy-Array. Zum Beispiel das maskierte Array von [2 x 5] unten:

m_arr = [[- - 1 - 1]
     [1 - - 1 1]]

Ausgabe des Entfernens eines führenden maskierten Elements wäre

m_arr = [[1 - 1]
     [1 - - 1 1]]

Ich habe versucht, komprimiertes Listenverständnis als zu verwenden

[m.compressed.tolist() for m in m_arr]

Aber ich habe noch keine Lösung, indem ich np.apply_along_axis mache !!

Answer 1

OK, machen Sie das maskierte Array:

In [96]: m_arr=np.ma.MaskedArray(np.arange(10).reshape(2,5),np.array([[1,1,0,1,0
    ...: ],[0,1,1,0,0]]))
In [97]: m_arr
Out[97]: 
masked_array(
  data=[[--, --, 2, --, 4],
        [5, --, --, 8, 9]],
  mask=[[ True,  True, False,  True, False],
        [False,  True,  True, False, False]],
  fill_value=999999)

Schauen Sie sich die 1d-Array-Attribute an, wenn wir iterieren:

In [99]: [(m.data,m.mask) for m in m_arr]
Out[99]: 
[(array([0, 1, 2, 3, 4]), array([ True,  True, False,  True, False])),
 (array([5, 6, 7, 8, 9]), array([False,  True,  True, False, False]))]

Entdecken Sie eine Maske:

In [100]: m_arr[0].mask
Out[100]: array([ True,  True, False,  True, False])
In [101]: np.logical_and.accumulate(m_arr[0].mask)
Out[101]: array([ True,  True, False, False, False])
In [104]: m_arr[0][~_101]
Out[104]: 
masked_array(data=[2, --, 4],
             mask=[False,  True, False],
       fill_value=999999)

wickeln Sie das in Funktion ein:

In [109]: def foo(m):
     ...:     mm = m.mask
     ...:     mm = ~np.logical_and.accumulate(mm)
     ...:     return m[mm]
     ...: 

und zeilenweise anwenden:

In [110]: [foo(m) for m in m_arr]
Out[110]: 
[masked_array(data=[2, --, 4],
              mask=[False,  True, False],
        fill_value=999999),
 masked_array(data=[5, --, --, 8, 9],
              mask=[False,  True,  True, False, False],
        fill_value=999999)]

====

In einer Folgefrage haben Sie versucht, das logical_andauf das gesamte Array anzuwenden (im Gegensatz zu zeilenweise):

In [132]: np.logical_and.accumulate(m_arr.mask)
Out[132]: 
array([[ True,  True, False,  True, False],
       [False,  True, False, False, False]])

Richtige Anwendung - zeilenweise:

In [133]: np.logical_and.accumulate(m_arr.mask, axis=1)
Out[133]: 
array([[ True,  True, False, False, False],
       [False, False, False, False, False]])

Mit Hilfe einer boolean Maske immer flacht das Ergebnis. Wir haben bereits klargestellt, dass das Ergebnis nicht 2d sein kann - zumindest nicht in einem allgemeinen Fall, in dem sich die Anzahl der wahren Werte pro Zeile unterscheidet.

In [134]: m_arr[~_]
Out[134]: 
masked_array(data=[2, --, 4, 5, --, --, 8, 9],
             mask=[False,  True, False, False,  True,  True, False, False],
       fill_value=999999)

Answer 2

Sie können das Gleiche tun, was mein Kommentar und die Antwort von @ hpaulj vorschlagen, eine richtige Anwendung zu verwenden, np.splitanstatt selbst eine Schleife zu schreiben.

Der Anfang des ersten Falsein jeder Zeile ist gegeben durch

start = np.argmin(m_arr.mask, axis=1)

Führen Sie dies mit einer Null in jeder Zeile zusammen und linearisieren Sie den Index, um einige Teilungspunkte zu erhalten:

pad = np.zeros(m_arr.shape[0], dtype=int)
indices = np.ravel(np.stack((pad, start), axis=-1) + np.arange(m_arr.shape[0])[:, None] * m_arr.shape[1])

Sie können dann sowohl den maskierten als auch den nicht maskierten Teil des Raveled-Arrays aufteilen:

m_arr = np.split(m_arr.ravel(), indices)[2::2]

Zeitliche Koordinierung

In diesem Fall nicht besonders interessant, aber ich habe einige Aufrufe der folgenden Funktionen verglichen:

def foo(m):
    mm = m.mask
    mm = ~np.logical_and.accumulate(mm)
    return m[mm]

def bar_hpaulj(x):
    return [foo(m) for m in x]

def bar_MadPhysicist(x):
    return np.split(x.ravel(), (np.stack((np.zeros(x.shape[0], dtype=int), np.argmin(x.mask, axis=1)), axis=-1) + np.arange(x.shape[0])[:, None] * x.shape[1]).ravel()
)[2::2]

Arrays wurden als zufällige Quadrate erzeugt nin {10, 100, 1000, 10000}:

m_arr = np.ma.MaskedArray(np.ones((n, n)), mask=np.random.randint(2, size=(n, n), dtype=bool))

Die Zeiten sind:

  n   |     bar_hpaulj    |  bar_MadPhysicist |
------+-------------------+-------------------+
   10 |  464 µs ± 1.54 µs |  966 µs ± 3.06 µs |
------+-------------------+-------------------+
  100 | 4.69 ms ± 20.2 µs | 8.31 ms ± 26.3 µs |
------+-------------------+-------------------+
 1000 |   67 ms ± 1.09 ms |  83.2 ms ± 309 µs |
------+-------------------+-------------------+
10000 |  2.38 s ± 29.5 ms |  835 ms ± 3.14 ms |
------+-------------------+-------------------+