Argsort'u azalan sırada kullanmak mümkün müdür?

Aşağıdaki kodu göz önünde bulundurun:

avgDists = np.array([1, 8, 6, 9, 4])
ids = avgDists.argsort()[:n]

Bu bana en nküçük elementlerin endekslerini veriyor . En yüksek elementlerin argsortindekslerini almak için bunu azalan sırada kullanmak mümkün müdür n?

Bir diziyi reddederseniz, en düşük öğeler en yüksek öğeler olur veya tersi de geçerlidir. Bu nedenle, en nyüksek elementlerin endeksleri :

(-avgDists).argsort()[:n]

Bu konuda akıl yürütmenin bir başka yolu, yorumlarda belirtildiği gibi , büyük öğelerin argsort'ta son geldiğini gözlemlemektir. Böylece, en nyüksek öğeleri bulmak için argsort'un kuyruğundan okuyabilirsiniz :

avgDists.argsort()[::-1][:n]

Her iki yöntem de zaman karmaşıklığında O (n log n) şeklindedir , çünkü argsortçağrı burada baskın terimdir. Ancak ikinci yaklaşımın güzel bir avantajı vardır: dizinin O (n) negatifliğini O (1) dilimi ile değiştirir. Döngülerin içindeki küçük dizilerle çalışıyorsanız, bu olumsuzlamadan kaçınmaktan bazı performans kazanımları elde edebilirsiniz ve büyük dizilerle çalışıyorsanız, olumsuzlama tüm dizinin bir kopyasını oluşturduğundan bellek kullanımından tasarruf edebilirsiniz.

Bu yöntemlerin her zaman eşdeğer sonuçlar vermediğini unutmayın: argsortörneğin, anahtar kelime bağımsız değişkenini geçerek kararlı bir sıralama uygulaması istenirse kind='mergesort', ilk strateji sıralama kararlılığını koruyacaktır, ancak ikinci strateji istikrarı bozacaktır (yani eşit konumlar öğeler ters alacak).

Örnek zamanlamalar:

100 şamandıra ve uzunluk 30 kuyruktan oluşan küçük bir dizi kullanarak, görüntüleme yöntemi yaklaşık% 15 daha hızlıydı

>>> avgDists = np.random.rand(100)
>>> n = 30
>>> timeit (-avgDists).argsort()[:n]
1.93 µs ± 6.68 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
>>> timeit avgDists.argsort()[::-1][:n]
1.64 µs ± 3.39 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
>>> timeit avgDists.argsort()[-n:][::-1]
1.64 µs ± 3.66 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Daha büyük diziler için argsort baskındır ve önemli bir zamanlama farkı yoktur

>>> avgDists = np.random.rand(1000)
>>> n = 300
>>> timeit (-avgDists).argsort()[:n]
21.9 µs ± 51.2 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
>>> timeit avgDists.argsort()[::-1][:n]
21.7 µs ± 33.3 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
>>> timeit avgDists.argsort()[-n:][::-1]
21.9 µs ± 37.1 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Aşağıdaki nedim'den gelen yorumun yanlış olduğunu lütfen unutmayın . Bu işlemlerin her ikisi de dizinin yalnızca farklı bir görünümünden geçiyor ve gerçekte veri kopyalamıyor olduğundan, tersine dönmeden önce veya sonra kesip kesmemek verimlilikte bir fark yaratmıyor.

Tıpkı Python gibi, [::-1]geri döndürülen diziyi tersine çevirir argsort()ve [:n]son n öğeyi verir:

>>> avgDists=np.array([1, 8, 6, 9, 4])
>>> n=3
>>> ids = avgDists.argsort()[::-1][:n]
>>> ids
array([3, 1, 2])

Bu yöntemin avantajı , avgDists'in idsbir görünümüdür :

>>> ids.flags
  C_CONTIGUOUS : False
  F_CONTIGUOUS : False
  OWNDATA : False
  WRITEABLE : True
  ALIGNED : True
  UPDATEIFCOPY : False

('OWNDATA' False, bunun bir kopya değil görünüm olduğunu gösterir)

Bunu yapmanın başka bir yolu şudur:

(-avgDists).argsort()[:n]

Sorun, bu çalışma şeklinin dizideki her öğenin negatifini oluşturmaktır:

>>> (-avgDists)
array([-1, -8, -6, -9, -4])

ANd bunun için bir kopya oluşturur:

>>> (-avgDists_n).flags['OWNDATA']
True

Yani her birine zaman ayırırsanız, bu çok küçük veri setiyle:

>>> import timeit
>>> timeit.timeit('(-avgDists).argsort()[:3]', setup="from __main__ import avgDists")
4.2879798610229045
>>> timeit.timeit('avgDists.argsort()[::-1][:3]', setup="from __main__ import avgDists")
2.8372560259886086

Görüntüleme yöntemi önemli ölçüde daha hızlıdır (ve hafızanın 1 / 2'sini kullanır ...)

Komutu kullanarak sıraladıktan sonra flip komutlarını numpy.flipud()veya numpy.fliplr()dizinleri azalan sırada almak için kullanabilirsiniz argsort. Genellikle yaptığım budur.

Kullanmak yerine np.argsortkullanabilirsiniz np.argpartition- sadece en düşük / en yüksek n öğelerinin indekslerine ihtiyacınız varsa.

Bu, tüm diziyi sıralamak zorunda değil, sadece ihtiyacınız olan kısmı ancak "bölümünüzdeki sipariş" undefined olduğunu unutmayın, bu nedenle doğru indeksleri verirken doğru şekilde sıralanamayabilirler:

>>> avgDists = [1, 8, 6, 9, 4]
>>> np.array(avgDists).argpartition(2)[:2]  # indices of lowest 2 items
array([0, 4], dtype=int64)

>>> np.array(avgDists).argpartition(-2)[-2:]  # indices of highest 2 items
array([1, 3], dtype=int64)

Dizinin bir kopyasını oluşturabilir ve sonra her bir öğeyi -1 ile çarpabilirsiniz.
Sonuç olarak, en büyük unsurlar en küçüğü olur.
Kopyadaki en küçük öğelerin uçları, orijinaldeki en büyük öğedir.

Örneğinizle:

avgDists = np.array([1, 8, 6, 9, 4])

En fazla n değer içeren dizinler elde edin:

ids = np.argpartition(avgDists, -n)[-n:]

Bunları azalan düzende sıralayın:

ids = ids[np.argsort(avgDists[ids])[::-1]]

Sonuçları alın (n = 4 için):

>>> avgDists[ids]
array([9, 8, 6, 4])

@Kanmani'nin ima ettiği gibi, yorumlanması daha kolay bir uygulama numpy.flip, aşağıdaki gibi kullanılabilir:

import numpy as np

avgDists = np.array([1, 8, 6, 9, 4])
ids = np.flip(np.argsort(avgDists))
print(ids)

Üye işlevleri yerine ziyaretçi kalıbını kullanarak işlem sırasını okumak daha kolaydır.

Başka bir yol, dgs veri çerçevesi olması ve ilk önce sıralamak istediğinizde, "df [np.argsort (-df [:, 0])]" gibi argsort argümanında yalnızca '-' kullanmaktır. sütun ('0' sütun numarası ile gösterilir). Sütun adını uygun şekilde değiştirin. Tabii ki, sütun sayısal bir sütun olmalıdır.