Ist es möglich, argsort in absteigender Reihenfolge zu verwenden?

Betrachten Sie den folgenden Code:

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

Dies gibt mir Indizes der nkleinsten Elemente. Ist es möglich, dasselbe argsortin absteigender Reihenfolge zu verwenden, um die Indizes der nhöchsten Elemente zu erhalten?

Wenn Sie ein Array negieren, werden die niedrigsten Elemente zu den höchsten Elementen und umgekehrt. Daher sind die Indizes der nhöchsten Elemente:

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

Eine andere Möglichkeit, dies zu begründen, besteht, wie in den Kommentaren erwähnt , darin, zu beobachten, dass die großen Elemente im Argsort an letzter Stelle stehen. Sie können also am Ende des Argsorts lesen, um die nhöchsten Elemente zu finden :

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

Beide Methoden sind zeitliche Komplexität von O (n log n) , da der argsortAufruf hier der dominierende Begriff ist. Der zweite Ansatz hat jedoch einen schönen Vorteil: Er ersetzt eine O (n) -Negation des Arrays durch ein O (1) -Slice. Wenn Sie mit kleinen Arrays in Schleifen arbeiten, können Sie einige Leistungssteigerungen erzielen, wenn Sie diese Negation vermeiden. Wenn Sie mit großen Arrays arbeiten, können Sie Speicherplatz sparen, da durch die Negation eine Kopie des gesamten Arrays erstellt wird.

Beachten Sie, dass diese Methoden nicht immer gleichwertige Ergebnisse liefern: Wenn eine stabile Sortierimplementierung angefordert wird argsort, z. B. durch Übergeben des Schlüsselwortarguments kind='mergesort', behält die erste Strategie die Sortierstabilität bei, die zweite Strategie unterbricht jedoch die Stabilität (dh die Positionen gleich) Artikel werden umgekehrt).

Beispielzeiten:

Bei Verwendung einer kleinen Anordnung von 100 Schwimmern und einer Länge von 30 Schwanz war die Ansichtsmethode etwa 15% schneller

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

Bei größeren Arrays ist der Argsort dominant und es gibt keinen signifikanten Zeitunterschied

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

Bitte beachten Sie, dass der Kommentar von nedim unten falsch ist. Ob vor oder nach dem Umkehren abgeschnitten werden soll, spielt keine Rolle für die Effizienz, da beide Vorgänge nur eine unterschiedliche Ansicht des Arrays anzeigen und keine Daten tatsächlich kopieren.

Genau wie bei Python [::-1]kehrt dies das von zurückgegebene Array um argsort()und [:n]gibt die letzten n Elemente an:

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

Der Vorteil dieser Methode ist , dass idsa Ansicht von avgDists:

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

(Wenn 'OWNDATA' falsch ist, ist dies eine Ansicht, keine Kopie.)

Ein anderer Weg, dies zu tun, ist so etwas wie:

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

Das Problem ist, dass dies so funktioniert, dass für jedes Element im Array ein Negativ erstellt wird:

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

ANd erstellt dazu eine Kopie:

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

Wenn Sie also jeweils eine Zeit festlegen, mit diesem sehr kleinen Datensatz:

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

Die Ansichtsmethode ist wesentlich schneller (und verwendet die Hälfte des Speichers ...)

Sie können die Flip-Befehle verwenden numpy.flipud()oder numpy.fliplr()die Indizes nach dem Sortieren mit dem argsortBefehl in absteigender Reihenfolge abrufen . Das mache ich normalerweise.

Anstatt zu verwenden np.argsort, könnten Sie verwenden np.argpartition- wenn Sie nur die Indizes der niedrigsten / höchsten n Elemente benötigen.

Dazu muss nicht das gesamte Array sortiert werden, sondern nur der Teil, den Sie benötigen. Beachten Sie jedoch, dass die "Reihenfolge innerhalb Ihrer Partition" undefiniert ist. Obwohl sie die richtigen Indizes enthält, sind sie möglicherweise nicht richtig geordnet:

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

Sie können eine Kopie des Arrays erstellen und dann jedes Element mit -1 multiplizieren.
Infolgedessen würden die vorher größten Elemente die kleinsten werden.
Die Unabhängigkeiten der n kleinsten Elemente in der Kopie sind die n größten Elemente im Original.

Wie @Kanmani angedeutet hat, kann eine einfacher zu interpretierende Implementierung verwendet werden numpy.flip, wie im Folgenden:

import numpy as np

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

Durch die Verwendung des Besuchermusters anstelle von Mitgliedsfunktionen ist es einfacher, die Reihenfolge der Vorgänge zu lesen.

Mit Ihrem Beispiel:

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

Erhalten Sie Indizes von n Maximalwerten:

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

Sortieren Sie sie in absteigender Reihenfolge:

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

Ergebnisse erhalten (für n = 4):

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

Eine andere Möglichkeit besteht darin, im Argument für argsort nur ein '-' zu verwenden, wie in: "df [np.argsort (-df [:, 0])]", vorausgesetzt, df ist der Datenrahmen und Sie möchten ihn nach dem ersten sortieren Spalte (dargestellt durch die Spaltennummer '0'). Ändern Sie den Spaltennamen entsprechend. Natürlich muss die Spalte eine numerische sein.