Überprüfen Sie, ob ein Numpy-Array an allen Rändern 0 hat [geschlossen]

Was wäre der schnellste Weg, um zu überprüfen, ob ein mehrdimensionales Numpy-Array auf allen Seiten 0 hat?

Für ein einfaches 2D-Beispiel habe ich also:

x = np.random.rand(5, 5)
assert np.sum(x[0:,  0]) == 0
assert np.sum(x[0,  0:]) == 0
assert np.sum(x[0:, -1]) == 0
assert np.sum(x[-1, 0:]) == 0

Während dies für 2D-Fälle in Ordnung ist, ist das Schreiben für höhere Dimensionen etwas mühsam und ich habe mich gefragt, ob es einen cleveren Numpy-Trick gibt, den ich hier verwenden kann, um es effizienter und auch wartbarer zu machen.

So geht's:

assert(all(np.all(np.take(x, index, axis=axis) == 0)
           for axis in range(x.ndim)
           for index in (0, -1)))

np.take macht das gleiche wie "ausgefallene" Indizierung.

Hier ist eine Antwort, die tatsächlich die Teile des Arrays untersucht, an denen Sie interessiert sind, und keine Zeit damit verschwendet, eine Maske von der Größe des gesamten Arrays zu erstellen. Es gibt eine Python-Level-Schleife, die jedoch kurz ist und deren Iterationen proportional zur Anzahl der Dimensionen anstelle der Größe des Arrays sind.

def all_borders_zero(array):
    if not array.ndim:
        raise ValueError("0-dimensional arrays not supported")
    for dim in range(array.ndim):
        view = numpy.moveaxis(array, dim, 0)
        if not (view[0] == 0).all():
            return False
        if not (view[-1] == 0).all():
            return False
    return True

Ich habe das Array umgeformt und es dann durchlaufen. Leider geht meine Antwort davon aus, dass Sie mindestens drei Dimensionen haben und bei normalen Matrizen Fehler auftreten. Sie müssten eine spezielle Klausel für 1 & 2-dimensional geformte Arrays hinzufügen. Darüber hinaus wird dies langsam sein, sodass es wahrscheinlich bessere Lösungen gibt.

x = np.array(
        [
            [
                [0 , 1, 1, 0],
                [0 , 2, 3, 0],
                [0 , 4, 5, 0]
            ],
            [
                [0 , 6, 7, 0],
                [0 , 7, 8, 0],
                [0 , 9, 5, 0]
            ]
        ])

xx = np.array(
        [
            [
                [0 , 0, 0, 0],
                [0 , 2, 3, 0],
                [0 , 0, 0, 0]
            ],
            [
                [0 , 0, 0, 0],
                [0 , 7, 8, 0],
                [0 , 0, 0, 0]
            ]
        ])

def check_edges(x):

    idx = x.shape
    chunk = np.prod(idx[:-2])
    x = x.reshape((chunk*idx[-2], idx[-1]))
    for block in range(chunk):
        z = x[block*idx[-2]:(block+1)*idx[-2], :]
        if not np.all(z[:, 0] == 0):
            return False
        if not np.all(z[:, -1] == 0):
            return False
        if not np.all(z[0, :] == 0):
            return False
        if not np.all(z[-1, :] == 0):
            return False

    return True

Welches wird produzieren

>>> False
>>> True

Grundsätzlich staple ich alle Maße übereinander und schaue sie dann durch, um ihre Kanten zu überprüfen.

Vielleicht ist der Ellipsenoperator genau das, wonach Sie suchen, was für viele Dimensionen funktioniert:

import numpy as np

# data
x = np.random.rand(2, 5, 5)
x[..., 0:, 0] = 0
x[..., 0, 0:] = 0
x[..., 0:, -1] = 0
x[..., -1, 0:] = 0

test = np.all(
    [
        np.all(x[..., 0:, 0] == 0),
        np.all(x[..., 0, 0:] == 0),
        np.all(x[..., 0:, -1] == 0),
        np.all(x[..., -1, 0:] == 0),
    ]
)

print(test)

Sie können eine sliceboolesche Maskierung verwenden, um die Aufgabe zu erledigen:

def get_borders(arr):
    s=tuple(slice(1,i-1) for i in a.shape)
    mask = np.ones(arr.shape, dtype=bool)
    mask[s] = False
    return(arr[mask])

Diese Funktion formt zuerst den "Kern" des Arrays in das Tupel sund erstellt dann eine Maske, die Truenur für die angrenzenden Punkte angezeigt wird. Die boolesche Indizierung liefert dann die Grenzpunkte.

Arbeitsbeispiel:

a = np.arange(16).reshape((4,4))

print(a)
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

borders = get_borders(a)
print(borders)
array([ 0,  1,  2,  3,  4,  7,  8, 11, 12, 13, 14, 15])

Dann erhalten np.all(borders==0)Sie die gewünschten Informationen.

Hinweis: Dies wird für eindimensionale Arrays unterbrochen, obwohl ich diese als Randfall betrachte. Sie sind wahrscheinlich besser dran, wenn Sie nur die beiden fraglichen Punkte dort überprüfen