vérifier si un tableau numpy a 0 sur toutes ses bordures [fermé]

Quel serait le moyen le plus rapide de vérifier si un tableau numpy multidimensionnel a 0 de tous les côtés.

Donc, pour un exemple 2D simple, j'ai:

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

Bien que cela soit correct pour les cas 2D à droite, l'écriture pour des dimensions plus élevées est un peu fastidieuse et je me demandais s'il y avait une astuce numpy intelligente que je peux utiliser ici pour la rendre efficace et plus facile à maintenir.

Voici comment procéder:

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

np.take fait la même chose que l'indexation "fantaisie".

Voici une réponse qui examine réellement les parties du tableau qui vous intéressent et ne perd pas de temps à construire un masque de la taille de l'ensemble du tableau. Il y a une boucle au niveau Python, mais elle est courte, avec des itérations proportionnelles au nombre de dimensions au lieu de la taille du tableau.

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

J'ai remodelé le tableau, puis itéré à travers lui. Malheureusement, ma réponse suppose que vous avez au moins trois dimensions et que vous vous tromperez pour les matrices normales, vous devrez ajouter une clause spéciale pour les tableaux en forme 1 et 2 dimensions. De plus, cela sera lent donc il y a probablement de meilleures solutions.

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

Qui produira

>>> False
>>> True

Fondamentalement, j'empile toutes les dimensions les unes sur les autres, puis je les regarde pour vérifier leurs bords.

peut-être que l'opérateur des points de suspension est ce que vous recherchez, qui fonctionnera pour de nombreuses dimensions:

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)

Vous pouvez utiliser le slicemasquage booléen pour faire le travail:

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

Cette fonction façonne d'abord le «noyau» du tableau dans le tuple s, puis crée un masque qui s'affiche Trueuniquement pour les points limitrophes. L'indexation booléenne délivre ensuite les points frontières.

Exemple de travail:

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

Ensuite, np.all(borders==0)vous donnera les informations souhaitées.

Remarque: cela se casse pour les tableaux unidimensionnels, bien que je considère ceux-ci comme un cas de bord. Vous feriez probablement mieux de vérifier les deux points en question