Czy można używać argsort w malejącej kolejności?

Rozważ następujący kod:

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

To daje mi wskaźniki nnajmniejszych elementów. Czy można użyć tego samego argsortw kolejności malejącej, aby uzyskać indeksy nnajwyższych elementów?

Jeśli zanegujesz tablicę, najniższe elementy stają się najwyższymi elementami i odwrotnie. Dlatego wskaźniki nnajwyższych elementów to:

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

Innym sposobem uzasadnienia tego, jak wspomniano w komentarzach , jest zaobserwowanie, że duże elementy pojawiają się na końcu w argsort. Tak więc możesz czytać z ogona argsort, aby znaleźć nnajwyższe elementy:

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

Obie metody mają złożoność czasową O (n log n) , ponieważ argsortwywołanie jest tutaj terminem dominującym. Ale drugie podejście ma dobrą zaletę: zastępuje negację O (n) tablicy wycięciem O (1) . Jeśli pracujesz z małymi tablicami wewnątrz pętli, możesz uzyskać pewien wzrost wydajności dzięki unikaniu tej negacji, a jeśli pracujesz z dużymi tablicami, możesz zaoszczędzić na zużyciu pamięci, ponieważ negacja tworzy kopię całej tablicy.

Zauważ, że metody te nie zawsze dają równoważne wyniki: jeśli wymagana jest stabilna implementacja sortowania argsort, np. Poprzez przekazanie argumentu słowa kluczowegokind='mergesort' , wówczas pierwsza strategia zachowa stabilność sortowania, ale druga strategia złamie stabilność (tj. Pozycje równe przedmioty zostaną odwrócone).

Przykładowe czasy:

Przy użyciu małej tablicy 100 pływaków i ogona o długości 30 metoda widoku była o około 15% szybsza

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

W przypadku większych tablic dominuje argsort i nie ma znaczącej różnicy czasu

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

Uwaga: poniższy komentarz nedim jest nieprawidłowy. To, czy obcinać przed czy po cofnięciu, nie ma różnicy w wydajności, ponieważ obie te operacje jedynie zmieniają widok tablicy inaczej i nie kopiują danych.

Podobnie jak Python, [::-1]odwraca tablicę zwracaną przez argsort()i [:n]daje ostatnie n elementów:

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

Zaletą tej metody jest to, że idsjest to widok z avgDists:

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

(„OWNDATA” to False oznacza, że ​​jest to widok, a nie kopia)

Innym sposobem na to jest coś takiego:

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

Problem polega na tym, że sposób ten polega na tworzeniu negatywu dla każdego elementu w tablicy:

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

I tworzy kopię, aby to zrobić:

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

Więc jeśli czas, każdy z tego bardzo małego zestawu danych:

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

Metoda przeglądania jest znacznie szybsza (i zajmuje 1/2 pamięci ...)

Możesz użyć poleceń odwracania numpy.flipud()lub numpy.fliplr()uzyskać indeksy w porządku malejącym po sortowaniu za pomocą argsortpolecenia. Tak zwykle robię.

Zamiast używać np.argsortmożesz użyćnp.argpartition - jeśli potrzebujesz tylko indeksów najniższych / najwyższych n elementów.

Nie wymaga to sortowania całej tablicy, ale tylko potrzebnej części, ale należy zauważyć, że „porządek wewnątrz partycji” jest niezdefiniowany, więc chociaż daje prawidłowe indeksy, może nie być poprawnie uporządkowany:

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

Możesz utworzyć kopię tablicy, a następnie pomnożyć każdy element przez -1.
W efekcie pierwszeństwo przed największymi elementami byłyby najmniejsze.
Wersety n najmniejszych elementów w kopii są n największymi elementami w oryginale.

Jak wskazał @Kanmani, można zastosować łatwiejszą do interpretacji implementację numpy.flip, jak poniżej:

import numpy as np

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

Używając wzorca gościa zamiast funkcji członka, łatwiej jest odczytać kolejność operacji.

Na przykład:

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

Uzyskaj indeksy n maksymalnych wartości:

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

Sortuj je w kolejności malejącej:

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

Uzyskaj wyniki (dla n = 4):

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

Innym sposobem jest użycie tylko „-” w argumencie dla argumentu argsort, jak w: „df [np.argsort (-df [:, 0])]”, pod warunkiem, że df jest ramką danych i chcesz ją posortować według pierwszej kolumna (reprezentowana przez numer kolumny „0”). Zmień odpowiednio nazwę kolumny. Oczywiście kolumna musi być liczbowa.