Trova vettore ordinato in serie numpy

Question

Ho bisogno di trovare un vettore in un numpy.array. Ad esempio, ho un np.array chiamato e e voglio trovare il vettore [1, 2] in e (nel senso che mi piacerebbe avere l'indice del vettore all'interno della matrice) ma a quanto pare il mio programma vede il vettore anche quando non è presente:

il codice che uso per costruire e nella seguente:

import numpy as np 
faces = np.array([[1,2,3,4],[5,6,2,1],[6,7,3,2],[7,8,4,3],[8,5,1,4],[8,7,6,5]]) 
e = np.zeros([6,4,2]) 
for k in range(len(faces)): 
    a = [faces[k][0], faces[k][1]] 
    b = [faces[k][1], faces[k][2]] 
    c = [faces[k][2], faces[k][3]] 
    d = [faces[k][3], faces[k][0]] 
    e[k] = np.array([a,b,c,d]) 
print('e: %s' %e) 

alcuna idea di come risolvere questo problema?

Answer 1

Prova:

e[np.all((e-np.array([1,2]))==0, axis=2)] 

Breve spiegazione. e-np.array([1,2]) restituisce [0,0] dove è [1,2] nell'array e. np.all(..., axis=2 restituisce l'array booleano: True se [0,0]False in caso contrario (quindi, ad esempio, [1,1] diventerà False). Infine, basta tagliarlo da e.

per ottenere l'indice di [1,2] 's (ci possono essere sub multipla vettore [1,2]):

np.argwhere(np.all((e-array([1,2]))==0, axis=2)) 

Answer 2

Non utilizzare Python in con gli array numpy.

Ci sono 6 coppie x 4 in e.

In [32]: e.shape 
Out[32]: (6, 4, 2) 

Siete alla ricerca di un elemento che soddisfa entrambi (cioè, all()) voci nella coppia [1, 2].

In [33]: (e == np.array([1, 2])).all(-1) 
Out[33]: 
array([[ True, False, False, False], 
     [False, False, False, False], 
     [False, False, False, False], 
     [False, False, False, False], 
     [False, False, False, False], 
     [False, False, False, False]], dtype=bool) 

Il -1 in all(-1) riferisce dell'ultima dimensione della matrice, la parte della forma che costituisce coppie. L'utilizzo di -1 è probabilmente più generale rispetto all'utilizzo di 2, che funzionerebbe anche in questo caso.

Ha trovato la corrispondenza giusta, l'unico valore True. Puoi vedere la forma di questo risultato ha un senso.

In [34]: (e == np.array([1, 2])).all(-1).shape 
Out[34]: (6, 4) 

per ottenere l'indice della prima partita si potrebbe fare

x, y = (e == np.array([1, 2])).all(-1).argmax(1).argmax(), (e == np.array([1, 2])).all(-1).argmax(0).argmax() 

ma utilizzando np.argwhere suggerito nella risposta di CT Zhu è sicuramente meglio.

Answer 3

Questo stamperà tutti gli indici di e e se è uguale a [1,2]. Se si desidera restituire gli indici, invece di stamparli, è possibile aggiungere (num, num2) a un altro elenco e ciò fornirebbe tutte le posizioni di [1,2]. Dovrebbe essere esteso per lavorare con array di più livelli.

for num, item in enumerate(e): 
    for num2, item2 in enumerate(item):          
     print ('e[{i}][{j}]: {truth}'.format(i=num, 
              j=num2, 
              truth = (item2 == [1,2]).all())) 

uscita:

e[0][0]: True                           
e[0][1]: False                           
e[0][2]: False                           
e[0][3]: False                           
e[1][0]: False                           
e[1][1]: False                           
e[1][2]: False                           
e[1][3]: False                           
e[2][0]: False                           
e[2][1]: False                           
e[2][2]: False                           
e[2][3]: False                           
e[3][0]: False                           
e[3][1]: False                           
e[3][2]: False                           
e[3][3]: False                           
e[4][0]: False                           
e[4][1]: False                           
e[4][2]: False                           
e[4][3]: False                           
e[5][0]: False                           
e[5][1]: False                           
e[5][2]: False                           
e[5][3]: False 

Answer 4

È anche possibile utilizzare il seguente trucco per visualizzare i vettori come singole voci di np.void DTYPE:

e = np.ascontiguousarray(e) 
dt = np.dtype((np.void, e.dtype.itemsize * e.shape[-1])) 
e_view = e.view(dt) 
search = np.array([1, 2], dtype=e.dtype).view(dt) 

È ora possibile estrarre le posizioni con np.in1d:

mask = np.in1d(e_view, search) 
indices = np.unravel_index(np.where(mask), e.shape[:-1]) 

>>> indices 
(array([[0]], dtype=int64), array([[0]], dtype=int64)) 

Gli array di restituzione sono una tupla con le righe e le colonne delle occorrenze di search, in questo caso ce n'è solo uno, a (0, 0).