Suchen Sie eindeutige Zeilen in numpy.array

Ich muss eindeutige Zeilen in a finden numpy.array.

Beispielsweise:

>>> a # I have
array([[1, 1, 1, 0, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [1, 1, 1, 0, 0, 0],
       [1, 1, 1, 1, 1, 0]])
>>> new_a # I want to get to
array([[1, 1, 1, 0, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [1, 1, 1, 1, 1, 0]])

Ich weiß, dass ich ein Set und eine Schleife über das Array erstellen kann, aber ich suche nach einer effizienten reinen numpyLösung. Ich glaube, dass es eine Möglichkeit gibt, den Datentyp auf void zu setzen, und dann könnte ich ihn einfach verwenden numpy.unique, aber ich konnte nicht herausfinden, wie er funktioniert.

Ab NumPy 1.13 kann einfach die Achse für die Auswahl eindeutiger Werte in einem beliebigen N-Dim-Array ausgewählt werden. Um eindeutige Zeilen zu erhalten, kann man Folgendes tun:

unique_rows = np.unique(original_array, axis=0)

Noch eine mögliche Lösung

np.vstack({tuple(row) for row in a})

Eine weitere Option für die Verwendung strukturierter Arrays ist die Verwendung einer Ansicht eines voidTyps, der die gesamte Zeile zu einem einzigen Element zusammenfügt:

a = np.array([[1, 1, 1, 0, 0, 0],
              [0, 1, 1, 1, 0, 0],
              [0, 1, 1, 1, 0, 0],
              [1, 1, 1, 0, 0, 0],
              [1, 1, 1, 1, 1, 0]])

b = np.ascontiguousarray(a).view(np.dtype((np.void, a.dtype.itemsize * a.shape[1])))
_, idx = np.unique(b, return_index=True)

unique_a = a[idx]

>>> unique_a
array([[0, 1, 1, 1, 0, 0],
       [1, 1, 1, 0, 0, 0],
       [1, 1, 1, 1, 1, 0]])

EDIT hinzugefügt np.ascontiguousarrayfolgende @ seberg Empfehlung. Dies verlangsamt die Methode, wenn das Array noch nicht zusammenhängend ist.

BEARBEITEN Das oben Genannte kann leicht beschleunigt werden, möglicherweise auf Kosten der Klarheit, indem Sie Folgendes tun:

unique_a = np.unique(b).view(a.dtype).reshape(-1, a.shape[1])

Zumindest auf meinem System ist es in Bezug auf die Leistung gleich oder sogar besser als die Lexsort-Methode:

a = np.random.randint(2, size=(10000, 6))

%timeit np.unique(a.view(np.dtype((np.void, a.dtype.itemsize*a.shape[1])))).view(a.dtype).reshape(-1, a.shape[1])
100 loops, best of 3: 3.17 ms per loop

%timeit ind = np.lexsort(a.T); a[np.concatenate(([True],np.any(a[ind[1:]]!=a[ind[:-1]],axis=1)))]
100 loops, best of 3: 5.93 ms per loop

a = np.random.randint(2, size=(10000, 100))

%timeit np.unique(a.view(np.dtype((np.void, a.dtype.itemsize*a.shape[1])))).view(a.dtype).reshape(-1, a.shape[1])
10 loops, best of 3: 29.9 ms per loop

%timeit ind = np.lexsort(a.T); a[np.concatenate(([True],np.any(a[ind[1:]]!=a[ind[:-1]],axis=1)))]
10 loops, best of 3: 116 ms per loop

Wenn Sie die Speicherkosten für die Konvertierung in eine Reihe von Tupeln oder eine andere ähnliche Datenstruktur vermeiden möchten, können Sie die strukturierten Arrays von numpy nutzen.

Der Trick besteht darin, Ihr ursprüngliches Array als strukturiertes Array anzuzeigen, wobei jedes Element einer Zeile des ursprünglichen Arrays entspricht. Dies macht keine Kopie und ist sehr effizient.

Als schnelles Beispiel:

import numpy as np

data = np.array([[1, 1, 1, 0, 0, 0],
                 [0, 1, 1, 1, 0, 0],
                 [0, 1, 1, 1, 0, 0],
                 [1, 1, 1, 0, 0, 0],
                 [1, 1, 1, 1, 1, 0]])

ncols = data.shape[1]
dtype = data.dtype.descr * ncols
struct = data.view(dtype)

uniq = np.unique(struct)
uniq = uniq.view(data.dtype).reshape(-1, ncols)
print uniq

Schauen Sie sich die Zwischenergebnisse an, um zu verstehen, was los ist.

Sobald wir die Dinge als strukturiertes Array betrachten, ist jedes Element im Array eine Zeile in Ihrem ursprünglichen Array. (Grundsätzlich ist es eine ähnliche Datenstruktur wie eine Liste von Tupeln.)

In [71]: struct
Out[71]:
array([[(1, 1, 1, 0, 0, 0)],
       [(0, 1, 1, 1, 0, 0)],
       [(0, 1, 1, 1, 0, 0)],
       [(1, 1, 1, 0, 0, 0)],
       [(1, 1, 1, 1, 1, 0)]],
      dtype=[('f0', '<i8'), ('f1', '<i8'), ('f2', '<i8'), ('f3', '<i8'), ('f4', '<i8'), ('f5', '<i8')])

In [72]: struct[0]
Out[72]:
array([(1, 1, 1, 0, 0, 0)],
      dtype=[('f0', '<i8'), ('f1', '<i8'), ('f2', '<i8'), ('f3', '<i8'), ('f4', '<i8'), ('f5', '<i8')])

Sobald wir ausgeführt werden numpy.unique, erhalten wir ein strukturiertes Array zurück:

In [73]: np.unique(struct)
Out[73]:
array([(0, 1, 1, 1, 0, 0), (1, 1, 1, 0, 0, 0), (1, 1, 1, 1, 1, 0)],
      dtype=[('f0', '<i8'), ('f1', '<i8'), ('f2', '<i8'), ('f3', '<i8'), ('f4', '<i8'), ('f5', '<i8')])

Das müssen wir dann als "normales" Array anzeigen ( _speichert das Ergebnis der letzten Berechnung in ipython, weshalb Sie sehen _.view...):

In [74]: _.view(data.dtype)
Out[74]: array([0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0])

Und dann wieder in ein 2D-Array umformen ( -1ist ein Platzhalter, der numpy anweist, die richtige Anzahl von Zeilen zu berechnen und die Anzahl der Spalten anzugeben):

In [75]: _.reshape(-1, ncols)
Out[75]:
array([[0, 1, 1, 1, 0, 0],
       [1, 1, 1, 0, 0, 0],
       [1, 1, 1, 1, 1, 0]])

Wenn Sie präziser sein möchten, können Sie dies natürlich wie folgt schreiben:

import numpy as np

def unique_rows(data):
    uniq = np.unique(data.view(data.dtype.descr * data.shape[1]))
    return uniq.view(data.dtype).reshape(-1, data.shape[1])

data = np.array([[1, 1, 1, 0, 0, 0],
                 [0, 1, 1, 1, 0, 0],
                 [0, 1, 1, 1, 0, 0],
                 [1, 1, 1, 0, 0, 0],
                 [1, 1, 1, 1, 1, 0]])
print unique_rows(data)

Was in ... endet:

[[0 1 1 1 0 0]
 [1 1 1 0 0 0]
 [1 1 1 1 1 0]]

np.uniqueWenn ich es ausführe, werden np.random.random(100).reshape(10,10)alle eindeutigen Einzelelemente zurückgegeben, aber Sie möchten die eindeutigen Zeilen, also müssen Sie sie zuerst in Tupel setzen:

array = #your numpy array of lists
new_array = [tuple(row) for row in array]
uniques = np.unique(new_array)

Nur so sehe ich, dass Sie die Typen ändern, um das zu tun, was Sie wollen, und ich bin mir nicht sicher, ob die Listeniteration, die in Tupel geändert werden soll, in Ordnung ist, wenn Sie nicht durchlaufen.

np.unique sortiert ein abgeflachtes Array und prüft dann, ob jedes Element dem vorherigen entspricht. Dies kann manuell ohne Abflachung erfolgen:

ind = np.lexsort(a.T)
a[ind[np.concatenate(([True],np.any(a[ind[1:]]!=a[ind[:-1]],axis=1)))]]

Diese Methode verwendet keine Tupel und sollte viel schneller und einfacher sein als andere hier angegebene Methoden.

HINWEIS: Eine frühere Version davon hatte nicht das Ind direkt nach einem [, was bedeutet, dass die falschen Indizes verwendet wurden. Außerdem macht Joe Kington einen guten Punkt , dass dies tut eine Vielzahl von Zwischenkopien machen. Die folgende Methode macht weniger, indem sie eine sortierte Kopie erstellt und dann Ansichten davon verwendet:

b = a[np.lexsort(a.T)]
b[np.concatenate(([True], np.any(b[1:] != b[:-1],axis=1)))]

Dies ist schneller und benötigt weniger Speicher.

Wenn Sie eindeutige Zeilen in einem ndarray suchen möchten, unabhängig davon, wie viele Dimensionen sich im Array befinden, funktioniert Folgendes:

b = a[lexsort(a.reshape((a.shape[0],-1)).T)];
b[np.concatenate(([True], np.any(b[1:]!=b[:-1],axis=tuple(range(1,a.ndim)))))]

Ein interessantes verbleibendes Problem wäre, wenn Sie entlang einer beliebigen Achse eines Arrays mit beliebigen Dimensionen sortieren / eindeutig sein möchten, was schwieriger wäre.

Bearbeiten:

Um die Geschwindigkeitsunterschiede zu demonstrieren, habe ich einige Tests in ipython der drei verschiedenen Methoden durchgeführt, die in den Antworten beschrieben sind. Mit Ihrem genauen a gibt es keinen allzu großen Unterschied, obwohl diese Version etwas schneller ist:

In [87]: %timeit unique(a.view(dtype)).view('<i8')
10000 loops, best of 3: 48.4 us per loop

In [88]: %timeit ind = np.lexsort(a.T); a[np.concatenate(([True], np.any(a[ind[1:]]!= a[ind[:-1]], axis=1)))]
10000 loops, best of 3: 37.6 us per loop

In [89]: %timeit b = [tuple(row) for row in a]; np.unique(b)
10000 loops, best of 3: 41.6 us per loop

Mit einem größeren a ist diese Version jedoch viel, viel schneller:

In [96]: a = np.random.randint(0,2,size=(10000,6))

In [97]: %timeit unique(a.view(dtype)).view('<i8')
10 loops, best of 3: 24.4 ms per loop

In [98]: %timeit b = [tuple(row) for row in a]; np.unique(b)
10 loops, best of 3: 28.2 ms per loop

In [99]: %timeit ind = np.lexsort(a.T); a[np.concatenate(([True],np.any(a[ind[1:]]!= a[ind[:-1]],axis=1)))]
100 loops, best of 3: 3.25 ms per loop

Hier ist eine weitere Variante für die @ Greg-Python-Antwort

np.vstack(set(map(tuple, a)))

Ich habe die vorgeschlagene Alternative auf Geschwindigkeit verglichen und festgestellt, dass die Void-View- uniqueLösung überraschenderweise uniquemit dem axisArgument sogar etwas schneller ist als Numpys native . Wenn Sie Geschwindigkeit suchen, werden Sie wollen

numpy.unique(
    a.view(numpy.dtype((numpy.void, a.dtype.itemsize*a.shape[1])))
    ).view(a.dtype).reshape(-1, a.shape[1])

Code zur Reproduktion der Handlung:

import numpy
import perfplot


def unique_void_view(a):
    return numpy.unique(
        a.view(numpy.dtype((numpy.void, a.dtype.itemsize*a.shape[1])))
        ).view(a.dtype).reshape(-1, a.shape[1])


def lexsort(a):
    ind = numpy.lexsort(a.T)
    return a[ind[
        numpy.concatenate((
            [True], numpy.any(a[ind[1:]] != a[ind[:-1]], axis=1)
            ))
        ]]


def vstack(a):
    return numpy.vstack({tuple(row) for row in a})


def unique_axis(a):
    return numpy.unique(a, axis=0)


perfplot.show(
    setup=lambda n: numpy.random.randint(2, size=(n, 20)),
    kernels=[unique_void_view, lexsort, vstack, unique_axis],
    n_range=[2**k for k in range(15)],
    logx=True,
    logy=True,
    xlabel='len(a)',
    equality_check=None
    )

Ich mochte keine dieser Antworten, weil keine Gleitkomma-Arrays im Sinne einer linearen Algebra oder eines Vektorraums handhabt, wobei zwei Zeilen, die „gleich“ sind, „innerhalb eines 𝜀“ bedeuten. Bei der einen Antwort mit einem Toleranzschwellenwert, https://stackoverflow.com/a/26867764/500207 , wurde der Schwellenwert sowohl als element- als auch als dezimalgenau angenommen. Dies funktioniert in einigen Fällen, ist jedoch mathematisch nicht so allgemein wie ein wahre Vektorentfernung.

Hier ist meine Version:

from scipy.spatial.distance import squareform, pdist

def uniqueRows(arr, thresh=0.0, metric='euclidean'):
    "Returns subset of rows that are unique, in terms of Euclidean distance"
    distances = squareform(pdist(arr, metric=metric))
    idxset = {tuple(np.nonzero(v)[0]) for v in distances <= thresh}
    return arr[[x[0] for x in idxset]]

# With this, unique columns are super-easy:
def uniqueColumns(arr, *args, **kwargs):
    return uniqueRows(arr.T, *args, **kwargs)

Die obige Public-Domain-Funktion verwendet scipy.spatial.distance.pdist, um den euklidischen (anpassbaren) Abstand zwischen jedem Zeilenpaar zu ermitteln. Dann vergleicht es jede Entfernung mit einer threshalten, um die Zeilen zu finden, die threshineinander liegen, und gibt nur eine Zeile von jedem threshCluster zurück.

Wie angedeutet, muss die Entfernung metricnicht euklidisch sein - pdistkann verschiedene Entfernungen berechnen, einschließlich cityblock(Manhattan-Norm) und cosine(Winkel zwischen Vektoren).

Wenn thresh=0(Standardeinstellung), müssen die Zeilen bitgenau sein, um als "eindeutig" zu gelten. Andere gute Werte für die threshVerwendung skalierter Maschinengenauigkeit, dh thresh=np.spacing(1)*1e3.

Warum nicht drop_duplicatesvon Pandas verwenden:

>>> timeit pd.DataFrame(image.reshape(-1,3)).drop_duplicates().values
1 loops, best of 3: 3.08 s per loop

>>> timeit np.vstack({tuple(r) for r in image.reshape(-1,3)})
1 loops, best of 3: 51 s per loop

Das numpy_indexed- Paket (Haftungsausschluss: Ich bin sein Autor) verpackt die von Jaime veröffentlichte Lösung in eine schöne und getestete Oberfläche sowie viele weitere Funktionen:

import numpy_indexed as npi
new_a = npi.unique(a)  # unique elements over axis=0 (rows) by default

np.unique arbeitet mit einer Liste von Tupeln:

>>> np.unique([(1, 1), (2, 2), (3, 3), (4, 4), (2, 2)])
Out[9]: 
array([[1, 1],
       [2, 2],
       [3, 3],
       [4, 4]])

Bei einer Liste von Listen wird a TypeError: unhashable type: 'list'

Basierend auf der Antwort auf dieser Seite habe ich eine Funktion geschrieben, die die Fähigkeit der MATLAB- unique(input,'rows')Funktion nachbildet , mit der zusätzlichen Funktion, Toleranz für die Überprüfung der Eindeutigkeit zu akzeptieren. Es gibt auch die Indizes zurück, so dass c = data[ia,:]und data = c[ic,:]. Bitte melden Sie, wenn Sie Unstimmigkeiten oder Fehler feststellen.

def unique_rows(data, prec=5):
    import numpy as np
    d_r = np.fix(data * 10 ** prec) / 10 ** prec + 0.0
    b = np.ascontiguousarray(d_r).view(np.dtype((np.void, d_r.dtype.itemsize * d_r.shape[1])))
    _, ia = np.unique(b, return_index=True)
    _, ic = np.unique(b, return_inverse=True)
    return np.unique(b).view(d_r.dtype).reshape(-1, d_r.shape[1]), ia, ic

Abgesehen von der hervorragenden Antwort von @Jaime besteht eine andere Möglichkeit, eine Zeile zu reduzieren, darin, a.strides[0](vorausgesetzt, sie aist C-zusammenhängend) zu verwenden, was gleich ist a.dtype.itemsize*a.shape[0]. Weiterhin void(n)ist eine Abkürzung für dtype((void,n)). Wir kommen endlich zu dieser kürzesten Version:

a[unique(a.view(void(a.strides[0])),1)[1]]

Zum

[[0 1 1 1 0 0]
 [1 1 1 0 0 0]
 [1 1 1 1 1 0]]

Versuchen Sie Folgendes für allgemeine Zwecke wie 3D oder höher mehrdimensionale verschachtelte Arrays:

import numpy as np

def unique_nested_arrays(ar):
    origin_shape = ar.shape
    origin_dtype = ar.dtype
    ar = ar.reshape(origin_shape[0], np.prod(origin_shape[1:]))
    ar = np.ascontiguousarray(ar)
    unique_ar = np.unique(ar.view([('', origin_dtype)]*np.prod(origin_shape[1:])))
    return unique_ar.view(origin_dtype).reshape((unique_ar.shape[0], ) + origin_shape[1:])

welches Ihren 2D-Datensatz erfüllt:

a = np.array([[1, 1, 1, 0, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [1, 1, 1, 0, 0, 0],
       [1, 1, 1, 1, 1, 0]])
unique_nested_arrays(a)

gibt:

array([[0, 1, 1, 1, 0, 0],
   [1, 1, 1, 0, 0, 0],
   [1, 1, 1, 1, 1, 0]])

Aber auch 3D-Arrays wie:

b = np.array([[[1, 1, 1], [0, 1, 1]],
              [[0, 1, 1], [1, 1, 1]],
              [[1, 1, 1], [0, 1, 1]],
              [[1, 1, 1], [1, 1, 1]]])
unique_nested_arrays(b)

gibt:

array([[[0, 1, 1], [1, 1, 1]],
   [[1, 1, 1], [0, 1, 1]],
   [[1, 1, 1], [1, 1, 1]]])

Keine dieser Antworten hat bei mir funktioniert. Ich gehe davon aus, dass meine eindeutigen Zeilen Zeichenfolgen und keine Zahlen enthielten. Diese Antwort aus einem anderen Thread hat jedoch funktioniert:

Quelle: https://stackoverflow.com/a/38461043/5402386

Sie können die Methoden der Listen .count () und .index () verwenden

coor = np.array([[10, 10], [12, 9], [10, 5], [12, 9]])
coor_tuple = [tuple(x) for x in coor]
unique_coor = sorted(set(coor_tuple), key=lambda x: coor_tuple.index(x))
unique_count = [coor_tuple.count(x) for x in unique_coor]
unique_index = [coor_tuple.index(x) for x in unique_coor]

Wir können das numerische numpy-Array mxn tatsächlich in ein numpy-String-Array mx 1 umwandeln. Versuchen Sie es mit der folgenden Funktion. Es bietet count , inverse_idx und usw., genau wie numpy.unique:

import numpy as np

def uniqueRow(a):
    #This function turn m x n numpy array into m x 1 numpy array storing 
    #string, and so the np.unique can be used

    #Input: an m x n numpy array (a)
    #Output unique m' x n numpy array (unique), inverse_indx, and counts 

    s = np.chararray((a.shape[0],1))
    s[:] = '-'

    b = (a).astype(np.str)

    s2 = np.expand_dims(b[:,0],axis=1) + s + np.expand_dims(b[:,1],axis=1)

    n = a.shape[1] - 2    

    for i in range(0,n):
         s2 = s2 + s + np.expand_dims(b[:,i+2],axis=1)

    s3, idx, inv_, c = np.unique(s2,return_index = True,  return_inverse = True, return_counts = True)

    return a[idx], inv_, c

Beispiel:

A = np.array([[ 3.17   9.502  3.291],
  [ 9.984  2.773  6.852],
  [ 1.172  8.885  4.258],
  [ 9.73   7.518  3.227],
  [ 8.113  9.563  9.117],
  [ 9.984  2.773  6.852],
  [ 9.73   7.518  3.227]])

B, inv_, c = uniqueRow(A)

Results:

B:
[[ 1.172  8.885  4.258]
[ 3.17   9.502  3.291]
[ 8.113  9.563  9.117]
[ 9.73   7.518  3.227]
[ 9.984  2.773  6.852]]

inv_:
[3 4 1 0 2 4 0]

c:
[2 1 1 1 2]

Lassen Sie uns die gesamte Numpy-Matrix als Liste abrufen, dann Duplikate aus dieser Liste löschen und schließlich unsere eindeutige Liste wieder in eine Numpy-Matrix zurückgeben:

matrix_as_list=data.tolist() 
matrix_as_list:
[[1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 0, 0], [1, 1, 1, 0, 0, 0], [1, 1, 1, 1, 1, 0]]

uniq_list=list()
uniq_list.append(matrix_as_list[0])

[uniq_list.append(item) for item in matrix_as_list if item not in uniq_list]

unique_matrix=np.array(uniq_list)
unique_matrix:
array([[1, 1, 1, 0, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [1, 1, 1, 1, 1, 0]])

Die einfachste Lösung besteht darin, die Zeilen zu einem einzelnen Element zu machen, indem Sie sie zu Zeichenfolgen machen. Jede Zeile kann dann mit numpy als Ganzes auf ihre Einzigartigkeit hin verglichen werden. Diese Lösung ist verallgemeinerbar. Sie müssen lediglich Ihr Array umformen und für andere Kombinationen transponieren. Hier ist die Lösung für das bereitgestellte Problem.

import numpy as np

original = np.array([[1, 1, 1, 0, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [0, 1, 1, 1, 0, 0],
       [1, 1, 1, 0, 0, 0],
       [1, 1, 1, 1, 1, 0]])

uniques, index = np.unique([str(i) for i in original], return_index=True)
cleaned = original[index]
print(cleaned)    

Wird geben:

 array([[0, 1, 1, 1, 0, 0],
        [1, 1, 1, 0, 0, 0],
        [1, 1, 1, 1, 1, 0]])

Schicken Sie meinen Nobelpreis per Post

import numpy as np
original = np.array([[1, 1, 1, 0, 0, 0],
                     [0, 1, 1, 1, 0, 0],
                     [0, 1, 1, 1, 0, 0],
                     [1, 1, 1, 0, 0, 0],
                     [1, 1, 1, 1, 1, 0]])
# create a view that the subarray as tuple and return unique indeies.
_, unique_index = np.unique(original.view(original.dtype.descr * original.shape[1]),
                            return_index=True)
# get unique set
print(original[unique_index])