Comparer des tableaux 2D de taille différente

Question

J'ai deux tableaux 2D de tailles différentes.

Le premier tableau comporte 3 lignes et 7 colonnes. Le deuxième tableau comporte 60 lignes et 7 colonnes.

array_1 = 
[[0., 0., 0., 0., 1., 1., 1.],
 [1., 0., 1., 0., 0., 1., 0.],
 [1., 1., 1., 0., 1., 0., 0.]]

array_3 =
[[0., 0., 0., 0., 0., 0., 0.],
 [0., 0., 0., 0., 0., 1., 1.],
 [0., 0., 0., 0., 1., 0., 0.],
 [0., 0., 0., 1., 0., 0., 0.],
 [0., 0., 0., 1., 0., 1., 1.],
 [0., 0., 0., 1., 1., 0., 0.],
 [0., 0., 0., 1., 1., 1., 1.],
 [0., 0., 1., 0., 0., 0., 0.],
 [0., 0., 1., 0., 0., 1., 1.],
 [0., 0., 1., 0., 1., 0., 0.],
 [0., 0., 1., 0., 1., 1., 1.],
 [0., 0., 1., 1., 0., 0., 0.],
 [0., 0., 1., 1., 0., 1., 1.],
 [0., 0., 1., 1., 1., 0., 0.],
 [0., 0., 1., 1., 1., 1., 1.],
 [0., 1., 0., 0., 0., 0., 0.],
 [0., 1., 0., 0., 0., 1., 0.],
 [0., 1., 0., 0., 1., 0., 1.],
 [0., 1., 0., 0., 1., 1., 1.],
 [0., 1., 0., 1., 0., 0., 0.],
 [0., 1., 0., 1., 0., 1., 0.],
 [0., 1., 0., 1., 1., 0., 1.],
 [0., 1., 0., 1., 1., 1., 1.],
 [0., 1., 1., 0., 0., 0., 0.],
 [0., 1., 1., 0., 0., 1., 0.],
 [0., 1., 1., 0., 1., 0., 1.],
 [0., 1., 1., 0., 1., 1., 1.],
 [0., 1., 1., 1., 0., 1., 0.],
 [0., 1., 1., 1., 1., 0., 1.],
 [0., 1., 1., 1., 1., 1., 1.],
 [1., 0., 0., 0., 0., 0., 0.],
 [1., 0., 0., 0., 0., 1., 0.],
 [1., 0., 0., 0., 1., 1., 0.],
 [1., 0., 0., 1., 0., 0., 1.],
 [1., 0., 0., 1., 0., 1., 1.],
 [1., 0., 0., 1., 1., 0., 1.],
 [1., 0., 0., 1., 1., 1., 1.],
 [1., 0., 1., 0., 0., 0., 0.],
 [1., 0., 1., 0., 0., 1., 0.],
 [1., 0., 1., 0., 1., 0., 0.],
 [1., 0., 1., 0., 1., 1., 0.],
 [1., 0., 1., 1., 0., 0., 1.],
 [1., 0., 1., 1., 0., 1., 1.],
 [1., 0., 1., 1., 1., 0., 1.],
 [1., 0., 1., 1., 1., 1., 1.],
 [1., 1., 0., 0., 0., 0., 0.],
 [1., 1., 0., 0., 0., 1., 0.],
 [1., 1., 0., 0., 1., 0., 0.],
 [1., 1., 0., 0., 1., 1., 0.],
 [1., 1., 0., 1., 0., 1., 0.],
 [1., 1., 0., 1., 1., 0., 0.],
 [1., 1., 0., 1., 1., 1., 0.],
 [1., 1., 1., 0., 0., 0., 1.],
 [1., 1., 1., 0., 0., 1., 1.],
 [1., 1., 1., 0., 1., 0., 1.],
 [1., 1., 1., 0., 1., 1., 1.],
 [1., 1., 1., 1., 0., 0., 1.],
 [1., 1., 1., 1., 0., 1., 1.],
 [1., 1., 1., 1., 1., 0., 1.],
 [1., 1., 1., 1., 1., 1., 1.]]

Pour l'instant, j'ai une fonction comme celle-ci :

def compare(arr_1, arr_2):
    return arr_1 == arr_2.all(axis=1)

qui ne renvoient qu'un False valeur.

Ce que je voudrais que la fonction fasse, c'est de comparer les lignes dans array_1 avec les lignes de array_2 en vérifiant essentiellement si l'une des lignes de la section array_1 correspond à n'importe quelle ligne de la liste array_2 .

Idéalement, un tableau booléen pourrait représenter cela comme suit : [True, False, True]

En gros, cela représente que la ligne 0 dans array_1 correspond à une ligne dans array_2 , rang 1 dans array_1 ne correspond pas à une ligne dans array_2 etc...

Answer 1

Vous pouvez utiliser la fonction suivante pour résoudre ce problème. Elle va itérer à travers le premier tableau, et vérifier si cette ligne existe dans le second, et enfin stocker la réponse dans la variable résultat.

def compare_arrays(arr_1, arr_2):
    result = []
    for row in arr_1:
        result.append(row in arr_2)
    return result

Answer 2

Afin de vérifier l'adhésion à 2d une approche consiste à les considérer comme des tableaux à une dimension. Nous pouvons donc prendre 1d des vues des deux tableaux et utiliser np.in1d pour trouver quelles lignes d'un tableau donné sont contenues dans un autre :

def view_as1d(a):
    return a.view(np.dtype((np.void, a.dtype.itemsize * a.shape[-1])))

np.in1d(view_as1d(array_1), view_as1d(array_3))

Answer 3

On dirait que vous voulez :

[row in array_3 for row in array_1]

Answer 4

Vous êtes sur la bonne voie avec all mais vous avez également besoin d'un any à travers les rangs. Vous pouvez y parvenir avec une nouvelle dimension et une nouvelle diffusion.

Créez d'abord un tableau 3x60x7 contenant les correspondances entre chaque ligne de arr1 y arr2 :

 m = (arr1[:, None, ...] == arr2[None, ...])

Ensuite, calculez si des lignes entières correspondent :

 n = m.all(axis=-1)

Maintenant vous pouvez vérifier s'il y a une correspondance de ligne complète dans arr2 pour chacune des lignes de arr1 :

 result = n.any(axis=-1)

En une phrase :

 (arr1[:, None, ...] == arr2[None, ...]).all(axis=-1).any(axis=-1)