Entfernen von Elementen aus einem array in ein anderes array

Sagen, ich habe diese 2D-arrays A und B.

Wie kann ich das entfernen von Elementen aus A in B. (Komplement in der Mengenlehre: A-B)

A=np.asarray([[1,1,1], [1,1,2], [1,1,3], [1,1,4]])
B=np.asarray([[0,0,0], [1,0,2], [1,0,3], [1,0,4], [1,1,0], [1,1,1], [1,1,4]])
#output = [[1,1,2], [1,1,3]]

Um genauer zu sein, ich möchte so etwas wie dies tun.

data = some numpy array
label = some numpy array
A = np.argwhere(label==0) #[[1 1 1], [1 1 2], [1 1 3], [1 1 4]]
B = np.argwhere(data>1.5) #[[0 0 0], [1 0 2], [1 0 3], [1 0 4], [1 1 0], [1 1 1], [1 1 4]]
out = np.argwhere(label==0 and data>1.5) #[[1 1 2], [1 1 3]]

nicht == wird funktionieren, ich bin nur raten, ich weiß nicht viel über numpy arrays, aus meinem python-Konsole habe ich diese >>>[1,1,1]==[1,1,1] >>>True
Eine einfache, nicht-numpy Lösung - [i for i in A for j in B if i==j]

InformationsquelleAutor Jee Seok Yoon | 2016-10-15

Basierend auf diese Lösung zu Suchen Sie die Zeile, Indizes, mehrere Werte in ein numpy-array, hier ist ein NumPy-basierte Lösung, mit weniger Speicherbedarf und könnte vorteilhaft sein, wenn die Arbeit mit großen arrays -

dims = np.maximum(B.max(0),A.max(0))+1
out = A[~np.in1d(np.ravel_multi_index(A.T,dims),np.ravel_multi_index(B.T,dims))]

Probe Gefahren -

In [38]: A
Out[38]: 
array([[1, 1, 1],
       [1, 1, 2],
       [1, 1, 3],
       [1, 1, 4]])

In [39]: B
Out[39]: 
array([[0, 0, 0],
       [1, 0, 2],
       [1, 0, 3],
       [1, 0, 4],
       [1, 1, 0],
       [1, 1, 1],
       [1, 1, 4]])

In [40]: out
Out[40]: 
array([[1, 1, 2],
       [1, 1, 3]])

Runtime test auf großen arrays -

In [107]: def in1d_approach(A,B):
     ...:     dims = np.maximum(B.max(0),A.max(0))+1
     ...:     return A[~np.in1d(np.ravel_multi_index(A.T,dims),\
     ...:                     np.ravel_multi_index(B.T,dims))]
     ...: 

In [108]: # Setup arrays with B as large array and A contains some of B's rows
     ...: B = np.random.randint(0,9,(1000,3))
     ...: A = np.random.randint(0,9,(100,3))
     ...: A_idx = np.random.choice(np.arange(A.shape[0]),size=10,replace=0)
     ...: B_idx = np.random.choice(np.arange(B.shape[0]),size=10,replace=0)
     ...: A[A_idx] = B[B_idx]
     ...:

Timings mit broadcasting basierte Lösungen -

In [109]: %timeit A[np.all(np.any((A-B[:, None]), axis=2), axis=0)]
100 loops, best of 3: 4.64 ms per loop # @Kasramvd's soln

In [110]: %timeit A[~((A[:,None,:] == B).all(-1)).any(1)]
100 loops, best of 3: 3.66 ms per loop

Timing mit weniger Hauptspeicher-basierten Lösung -

In [111]: %timeit in1d_approach(A,B)
1000 loops, best of 3: 231 µs per loop

Weitere Leistungssteigerung

in1d_approach reduziert jede Zeile betrachtet man jede Zeile als eine Indizierung Tupel. Wir können das gleiche tun, ein bisschen mehr effizient durch die Einführung der matrix-Multiplikation mit np.dot wie so

def in1d_dot_approach(A,B):
    cumdims = (np.maximum(A.max(),B.max())+1)**np.arange(B.shape[1])
    return A[~np.in1d(A.dot(cumdims),B.dot(cumdims))]

Lassen Sie uns testen Sie es gegen die Vorherige auf viel größere arrays -

In [251]: # Setup arrays with B as large array and A contains some of B's rows
     ...: B = np.random.randint(0,9,(10000,3))
     ...: A = np.random.randint(0,9,(1000,3))
     ...: A_idx = np.random.choice(np.arange(A.shape[0]),size=10,replace=0)
     ...: B_idx = np.random.choice(np.arange(B.shape[0]),size=10,replace=0)
     ...: A[A_idx] = B[B_idx]
     ...: 

In [252]: %timeit in1d_approach(A,B)
1000 loops, best of 3: 1.28 ms per loop

In [253]: %timeit in1d_dot_approach(A, B)
1000 loops, best of 3: 1.2 ms per loop

Ihre in1d_approach dauert 30 sec, in1d_dot_approach dauert 45 sec in mein Programm. Meine numpy Arrays dtype=np.uint8. Also getestet habe ich es mit deinen genauen code mit dtype=np.uint8 parameter für A, B, Dot-Funktion gibt mir 567 nano-Sekunden, die original-takes me 539 nano-Sekunden. Eine Erklärung, warum kleinere Datentyp gibt die ursprüngliche Funktion, bessere timing?
Nun, einfach, weil weniger Genauigkeit Datentypen belegen würde weniger Speicher im Hinblick auf Ihre binären bits und so entstehen weniger Speicher-Belegung und dass in den meisten Fällen übersetzt, um eine schnellere Verarbeitung als die Verarbeitung weniger Daten, da eine geringe Anzahl der binären bits sind zur Darstellung der einzelnen Nummer. Du musst Bedenken, dass auf der untersten Ebene, CPUs verarbeiten von binären Daten. Die Hoffnung, dass Sinn gemacht!
Ich Frage, warum ist in1d_approach(A,B) langsamer als in1d_dot_approach(A, B) beim Umgang mit Gleitkomma, aber schneller bei integer? Ist es nur, wie numpy gebaut wurde? Warum matrix-Multiplikation ausführen, besser mit floating point/ schlechter mit ganzen zahlen (im Vergleich zu anderen Methoden)?

InformationsquelleAutor Divakar

Hier ist ein Numpythonic Ansatz mit Rundfunk:

In [83]: A[np.all(np.any((A-B[:, None]), axis=2), axis=0)]
Out[83]: 
array([[1, 1, 2],
       [1, 1, 3]])

Hier ist eine timeit mit anderen Antwort:

In [90]: def cal_diff(A, B):
   ....:     A_rows = A.view([('', A.dtype)] * A.shape[1])
   ....:     B_rows = B.view([('', B.dtype)] * B.shape[1])
   ....:     return np.setdiff1d(A_rows, B_rows).view(A.dtype).reshape(-1, A.shape[1])
   ....: 

In [93]: %timeit cal_diff(A, B)
10000 loops, best of 3: 54.1 µs per loop

In [94]: %timeit A[np.all(np.any((A-B[:, None]), axis=2), axis=0)]
100000 loops, best of 3: 9.41 µs per loop

# Even better with Divakar's suggestion
In [97]: %timeit A[~((A[:,None,:] == B).all(-1)).any(1)]
100000 loops, best of 3: 7.41 µs per loop

Gut, wenn Sie auf der Suche nach einem schnelleren Weg, sollten Sie auf der Suche nach Möglichkeiten, die Verringerung der Anzahl der Vergleiche. In diesem Fall (ohne Berücksichtigung der Reihenfolge) generieren Sie eine eindeutige Nummer, die aus Ihren Zeilen und vergleichen Sie die zahlen, die getan werden kann, mit der Summe der Elemente, die Kraft der zwei.

Hier ist der benchmark mit Divakar ist in1d Ansatz:

In [144]: def in1d_approach(A,B):
   .....:         dims = np.maximum(B.max(0),A.max(0))+1
   .....:         return A[~np.in1d(np.ravel_multi_index(A.T,dims),\
   .....:                          np.ravel_multi_index(B.T,dims))]
   .....: 

In [146]: %timeit in1d_approach(A, B)
10000 loops, best of 3: 23.8 µs per loop

In [145]: %timeit A[~np.in1d(np.power(A, 2).sum(1), np.power(B, 2).sum(1))]
10000 loops, best of 3: 20.2 µs per loop

Können Sie np.diff zu erhalten, die eine Bestellung unabhängiges Ergebnis:

In [194]: B=np.array([[0, 0, 0,], [1, 0, 2,], [1, 0, 3,], [1, 0, 4,], [1, 1, 0,], [1, 1, 1,], [1, 1, 4,], [4, 1, 1]])

In [195]: A[~np.in1d(np.diff(np.diff(np.power(A, 2))), np.diff(np.diff(np.power(B, 2))))]
Out[195]: 
array([[1, 1, 2],
       [1, 1, 3]])

In [196]: %timeit A[~np.in1d(np.diff(np.diff(np.power(A, 2))), np.diff(np.diff(np.power(B, 2))))]
10000 loops, best of 3: 30.7 µs per loop

Benchmark mit Divakar setup:

In [198]: B = np.random.randint(0,9,(1000,3))

In [199]: A = np.random.randint(0,9,(100,3))

In [200]: A_idx = np.random.choice(np.arange(A.shape[0]),size=10,replace=0)

In [201]: B_idx = np.random.choice(np.arange(B.shape[0]),size=10,replace=0)

In [202]: A[A_idx] = B[B_idx]

In [203]: %timeit A[~np.in1d(np.diff(np.diff(np.power(A, 2))), np.diff(np.diff(np.power(B, 2))))]
10000 loops, best of 3: 137 µs per loop

In [204]: %timeit A[~np.in1d(np.power(A, 2).sum(1), np.power(B, 2).sum(1))]
10000 loops, best of 3: 112 µs per loop

In [205]: %timeit in1d_approach(A, B)
10000 loops, best of 3: 115 µs per loop

Timing mit größeren arrays (Divakar die Lösung ist etwas schneller):

In [231]: %timeit A[~np.in1d(np.diff(np.diff(np.power(A, 2))), np.diff(np.diff(np.power(B, 2))))]
1000 loops, best of 3: 1.01 ms per loop

In [232]: %timeit A[~np.in1d(np.power(A, 2).sum(1), np.power(B, 2).sum(1))]
1000 loops, best of 3: 880 µs per loop

In [233]:  %timeit in1d_approach(A, B)
1000 loops, best of 3: 807 µs per loop

Schön! War etwa das gleiche posten!
Eigentlich mit equality besser sein könnte, auf die Leistung : A[~((A[:,None,:] == B).all(-1)).any(1)].
Große Lösung 🙂
In der Tat, das ist Nett!
Schätzen Sie die updates, vielen Dank!

InformationsquelleAutor Kasrâmvd

9

gibt es eine einfache Lösung, mit list comprehension,
```
A = [i for i in A if i not in B]
```
Ergebnis
```
[[1, 1, 2], [1, 1, 3]]
```
Liste Verständnis, es ist nicht das entfernen der Elemente aus dem array, Es ist nur eine Verlagerung,

wenn Sie möchten, entfernen Sie die Elemente, die diese Methode verwenden,
```
for i in B:
     if i in A:
     A.remove(i)
```
InformationsquelleAutor Rahul K P

Wenn Sie es tun möchten die numpy Weg,

import numpy as np

A = np.array([[1, 1, 1,], [1, 1, 2], [1, 1, 3], [1, 1, 4]])
B = np.array([[0, 0, 0], [1, 0, 2], [1, 0, 3], [1, 0, 4], [1, 1, 0], [1, 1, 1], [1, 1, 4]])
A_rows = A.view([('', A.dtype)] * A.shape[1])
B_rows = B.view([('', B.dtype)] * B.shape[1])

diff_array = np.setdiff1d(A_rows, B_rows).view(A.dtype).reshape(-1, A.shape[1])

Als @Rahul vorgeschlagen, für eine nicht numpy einfache Lösung,

diff_array = [i for i in A if i not in B]

Ich denke, Sie werden immer falsche Ergebnis.
Vielen Dank für das heads-up. Aktualisiert.

InformationsquelleAutor R. S. Nikhil Krishna

4

Anderen nicht-numpy Lösung:
```
[i for i in A if i not in B]
```
InformationsquelleAutor liuyihe

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.