Numpy.array içindeki benzersiz satırları bulun

Birinde benzersiz satırlar bulmam gerekiyor numpy.array.

Örneğin:

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

Ben dizi üzerinde bir dizi oluşturmak ve döngü biliyorum, ama verimli bir saf numpyçözüm arıyorum . Veri türünü hükümsüz hale getirmenin bir yolu olduğuna inanıyorum ve sonra sadece kullanabilirim numpy.unique, ancak nasıl çalıştıracağını anlayamadım.

NumPy 1.13'ten itibaren, herhangi bir N-dim dizisindeki benzersiz değerlerin seçimi için eksen seçilebilir. Benzersiz satırlar elde etmek için aşağıdakiler yapılabilir:

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

Yine olası bir çözüm daha

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

Yapısal dizilerin kullanımı için başka bir seçenek void, tüm satırı tek bir öğeye birleştiren bir türün görünümünü kullanmaktır :

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

DÜZENLEME Eklendi np.ascontiguousarray@ Seberg önerilerini takip. Dizi bitişik değilse yöntem yavaşlar.

DÜZENLEME Yukarıdakiler, belki de netlik pahasına, aşağıdakileri yaparak hafifçe hızlandırılabilir:

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

Ayrıca, en azından benim sistemimde, performans akıllıca lexsort yönteminden daha düşük veya daha iyi:

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

Bir dizi tuple veya benzer bir veri yapısına dönüştürme bellek maliyetinden kaçınmak istiyorsanız, numpy'nin yapılandırılmış dizilerinden yararlanabilirsiniz.

Hile, orijinal dizinizi, her öğenin orijinal dizinin bir satırına karşılık geldiği yapılandırılmış bir dizi olarak görüntülemektir. Bu bir kopya oluşturmaz ve oldukça etkilidir.

Kısa bir örnek olarak:

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

Neler olduğunu anlamak için aracı sonuçlara bir göz atın.

İşleri yapılandırılmış bir dizi olarak görüntüledikten sonra, dizideki her öğe orijinal dizinizdeki bir satırdır. (Temel olarak, tuples listesine benzer bir veri yapısıdır.)

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

Bir kez koştuğumuzda numpy.unique, yapılandırılmış bir dizi geri alırız:

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

Daha sonra "normal" bir dizi olarak görüntülememiz gerektiğini ( _son hesaplamanın sonucunu saklar ipython, bu yüzden görüyorsunuz _.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])

Ve sonra bir 2D diziye yeniden şekillendirin ( -1numpy'ye doğru satır sayısını hesaplamasını söyleyen, sütun sayısını veren bir yer tutucudur):

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

Açıkçası, daha özlü olmak istiyorsanız, şöyle yazabilirsiniz:

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)

Sonuç:

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

np.uniqueBen çalıştırdığınızda np.random.random(100).reshape(10,10)tüm benzersiz öğeleri döndürür, ancak benzersiz satırları istersiniz, bu yüzden önce onları tuples'e koymanız gerekir:

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

İstediğinizi yapmak için türleri değiştirdiğinizi görmenin tek yolu budur.

np.unique, düzleştirilmiş bir diziyi sıralayarak ve ardından her bir öğenin öncekine eşit olup olmadığına bakarak çalışır. Bu, düzleştirmeden manuel olarak yapılabilir:

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

Bu yöntem tuples kullanmaz ve burada verilen diğer yöntemlerden çok daha hızlı ve basit olmalıdır.

NOT: Bunun önceki bir sürümünde ['nin hemen ardından ind yoktu, bu da yanlış indekslerin kullanıldığı anlamına geliyor. Ayrıca, Joe Kington bunun çeşitli ara kopyalar yaptığı konusunda iyi bir noktaya değiniyor. Aşağıdaki yöntem, sıralı bir kopya oluşturarak ve ardından görünümlerini kullanarak daha az yapar:

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

Bu daha hızlıdır ve daha az bellek kullanır.

Ayrıca, dizide kaç boyut olduğuna bakılmaksızın bir ndarray'de benzersiz satırlar bulmak istiyorsanız , aşağıdakiler işe yarayacaktır:

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

İlginç bir sorun, rasgele boyutlu bir dizinin rasgele bir ekseni boyunca sıralamak / benzersiz yapmak istiyorsanız, daha zor olacak bir şey olurdu.

Düzenle:

Hız farklılıklarını göstermek için, cevaplarda açıklanan üç farklı yöntemin ipython'unda birkaç test yaptım. İle senin bu sürüm biraz daha hızlı olsa kesin a, çok fazla bir fark yoktur:

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

Bununla birlikte, daha büyük bir a ile bu sürüm çok, çok daha hızlı olur:

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

İşte @Greg pitonik cevabı için başka bir varyasyon

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

Ben hız için önerilen alternatifi karşılaştırmış ve şaşırtıcı bir şekilde, geçersiz görünüm buldum uniqueçözümü bile biraz daha hızlı numpy doğal daha uniqueile axisargüman. Hız arıyorsanız,

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

Grafiği yeniden oluşturmak için kod:

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
    )

Bu cevapların hiçbirini beğenmedim, çünkü hiçbiri kayan nokta dizilerini doğrusal bir cebir veya vektör uzayı anlamında işlemez; burada iki satır “eşit”, “bazı within içinde” anlamına gelir. Tolerans eşiği olan bir cevap olan https://stackoverflow.com/a/26867764/500207 , eşiği hem öğe hem de ondalık olarak aldı hassasiyetle aldı, bu da bazı durumlarda işe yarıyor ancak matematiksel olarak genel gerçek vektör mesafesi.

İşte benim versiyonum:

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)

Yukarıdaki herkese açık alan adı işlevi scipy.spatial.distance.pdist , her bir satır çifti arasındaki Öklid (özelleştirilebilir) mesafesini bulmak için kullanılır . Daha sonra, birbirinin threshiçindeki satırları bulmak için her bir mesafeyi bir eskiyle karşılaştırır ve her birinden threshyalnızca bir satır döndürürthresh -cluster öğesinden .

Belirtildiği gibi, mesafenin metricÖklid olması gerekmez - (Manhattan normu) ve (vektörler arasındaki açı ) pdistdahil olmak üzere çeşitli mesafeleri hesaplayabilir .cityblockcosine

Eğer thresh=0(varsayılan), sonra satır bit tam “benzersiz” dikkate alınması gereken olmalıdır. threshÖlçekli makine hassasiyeti için diğer iyi değerler , yani,thresh=np.spacing(1)*1e3 .

Neden drop_duplicatespandalardan kullanmıyorsunuz :

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

Numpy_indexed paketi (uyarı: Ben onun yazarım) güzel Meydanı Jaime tarafından gönderildi çözümü test edilmiş arayüz, artı çok daha fazla özellik sarar:

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

np.unique eserlerine tuples listesi verildi:

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

Listelerin bir listesi ile TypeError: unhashable type: 'list'

Bu sayfadaki cevaba dayanarak unique(input,'rows'), benzersizliği kontrol etmek için toleransı kabul eden ek özellik ile MATLAB işlevinin yeteneğini çoğaltan bir işlev yazdım . Ayrıca, c = data[ia,:]ve gibi endeksleri döndürür data = c[ic,:]. Herhangi bir tutarsızlık veya hata görüyorsanız lütfen bildirin.

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

@Jaime mükemmel cevabının ötesinde, bir satırı daraltmanın başka bir yolu da eşittir a.strides[0]( aC-bitişik olduğu varsayılır) kullanır a.dtype.itemsize*a.shape[0]. Ayrıca void(n)bir kısayol dtype((void,n)). sonunda bu en kısa sürüme ulaşıyoruz:

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

İçin

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

3D veya daha yüksek çok boyutlu iç içe diziler gibi genel amaçlar için şunu deneyin:

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

2D veri kümenizi karşılayan:

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)

verir:

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

Ama aynı zamanda 3D diziler:

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)

verir:

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

Bu cevapların hiçbiri benim için işe yaramadı. Benzersiz satırlarımın sayıları değil, dizeleri içerdiğini varsayıyorum. Ancak başka bir evreden gelen bu cevap işe yaradı:

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

.Count () ve .index () listesinin yöntemlerini kullanabilirsiniz

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]

Aslında mxn sayısal numpy dizisini mx 1 numpy dize dizisine dönüştürebiliriz, lütfen aşağıdaki işlevi kullanmayı deneyin , numpy.unique gibi count , inverse_idx vb. Sağlar:

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

Misal:

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]

Numpy matrisinin tamamını bir liste olarak alalım, ardından bu listeden kopyaları bırakalım ve son olarak benzersiz listemizi tekrar numpy matrisine döndürelim:

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

En basit çözüm, satırları dizeler yaparak tek bir öğe yapmaktır. Daha sonra her satır numpy kullanarak benzersizliği için bir bütün olarak karşılaştırılabilir. Bu çözüm genelleştirilebilir, sadece dizinizi diğer kombinasyonlar için yeniden şekillendirmeniz ve aktarmanız gerekir. İşte size sunulan sorunun çözümü.

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)    

Verecek:

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

Nobel ödülümü postayla gönder

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