Bagaimana cara menghapus elemen bertopeng utama dalam array numpy?

Question

Bagaimana menghapus elemen bertopeng utama dari array numpy. misalnya larik bertopeng [2 x 5] di bawah ini:

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

keluaran dari penghapusan elemen bertopeng utama adalah

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

Saya mencoba menggunakan kompres dalam pemahaman daftar sebagai

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

Tetapi belum mendapatkan solusi bahkan dengan melakukan np.apply_along_axis !!

Answer 1

OK, buat array bertopeng:

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)

Lihatlah atribut array 1d saat kita mengulang:

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]))]

Jelajahi satu topeng:

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)

bungkus itu dalam fungsi:

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

dan terapkan baris demi baris:

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)]

====

Dalam pertanyaan tindak lanjut Anda mencoba menerapkan logical_andke seluruh larik (sebagai lawan baris demi baris):

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

Aplikasi yang benar - per baris:

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

Menggunakan topeng boolean selalu meratakan hasilnya. Kami sudah menjelaskan bahwa hasilnya tidak boleh 2d - setidaknya tidak dalam kasus umum di mana jumlah nilai sebenarnya per baris berbeda.

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

Anda dapat melakukan hal yang sama seperti yang disarankan oleh komentar saya dan jawaban @ hpaulj menggunakan aplikasi yang tepat np.splitdaripada menulis loop sendiri.

Awal dari yang pertama Falsedi setiap baris diberikan oleh

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

Gabungkan itu dengan nol di setiap baris, dan linierisasi indeks untuk mendapatkan beberapa titik pemisahan:

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])

Anda kemudian dapat memisahkan bagian yang bertopeng dan tidak bertopeng dari larik raveled:

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

Pengaturan waktu

Tidak terlalu menarik dalam hal ini, tetapi saya membandingkan beberapa panggilan ke fungsi berikut:

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]

Array dibuat sebagai kotak acak untuk ndi {10, 100, 1000, 10000}:

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

Waktunya adalah:

  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 |
------+-------------------+-------------------+