เป็นไปได้ไหมที่จะใช้ argsort เรียงลำดับจากมากไปน้อย

พิจารณารหัสต่อไปนี้:

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

สิ่งนี้ทำให้ฉันมีดัชนีnองค์ประกอบที่เล็กที่สุด เป็นไปได้ไหมที่จะใช้สิ่งนี้argsortตามลำดับจากมากไปน้อยเพื่อให้ได้ดัชนีของnองค์ประกอบสูงสุด?

ถ้าคุณปฏิเสธอาร์เรย์องค์ประกอบที่ต่ำที่สุดจะกลายเป็นองค์ประกอบที่สูงที่สุดและในทางกลับกัน ดังนั้นดัชนีของnองค์ประกอบสูงสุดคือ:

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

วิธีการเกี่ยวกับเหตุผลนี้ก็เป็นที่กล่าวถึงในการแสดงความคิดเห็นเป็นจะสังเกตเห็นว่าองค์ประกอบใหญ่จะมาล่าสุดใน argsort ดังนั้นคุณสามารถอ่านจากท้ายของ argsort เพื่อค้นหาnองค์ประกอบสูงสุด:

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

ทั้งสองวิธีคือ ความซับซ้อนของเวลาO (n log n)เนื่องจากการargsortโทรเป็นคำศัพท์หลักที่นี่ แต่วิธีการที่สองมีข้อได้เปรียบที่ดี: มันแทนที่O (n) negation ของอาร์เรย์ที่มีชิ้นO (1) หากคุณทำงานกับอาร์เรย์ขนาดเล็กภายในลูปคุณอาจได้รับประสิทธิภาพเพิ่มขึ้นจากการหลีกเลี่ยงการปฏิเสธและหากคุณทำงานกับอาร์เรย์ขนาดใหญ่คุณสามารถบันทึกการใช้หน่วยความจำได้เนื่องจากการลบสร้างสำเนาของทั้งอาร์เรย์

โปรดทราบว่าวิธีการเหล่านี้ไม่ได้ให้ผลลัพธ์ที่เท่าเทียมกันเสมอ: หากมีการร้องขอให้มีการใช้งานการจัดเรียงที่เสถียรargsortเช่นโดยการผ่านอาร์กิวเมนต์คำหลักkind='mergesort'กลยุทธ์แรกจะรักษาความมั่นคงในการเรียงลำดับ แต่กลยุทธ์ที่สองจะทำลายเสถียรภาพ (เช่นตำแหน่งที่เท่าเทียมกัน รายการจะได้รับการย้อนกลับ)

ตัวอย่างการจับเวลา:

ใช้อาร์เรย์ขนาดเล็กจำนวน 100 ลอยและความยาว 30 หางวิธีการดูจะเร็วขึ้นประมาณ 15%

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

สำหรับอาร์เรย์ขนาดใหญ่ argsort มีความโดดเด่นและไม่มีความแตกต่างของเวลาอย่างมีนัยสำคัญ

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

โปรดทราบว่าความคิดเห็นจาก nedimด้านล่างไม่ถูกต้อง ไม่ว่าจะตัดทอนก่อนหรือหลังการย้อนกลับไม่ทำให้ประสิทธิภาพแตกต่างกันเนื่องจากการดำเนินการทั้งสองนี้จะทำให้มุมมองของอาเรย์นั้นแตกต่างกันและไม่คัดลอกข้อมูลจริง

เช่นเดียวกับ Python ในการ[::-1]ย้อนกลับอาร์เรย์ที่ส่งคืนโดยargsort()และ[:n]ให้องค์ประกอบสุดท้ายที่ n:

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

ข้อดีของวิธีนี้idsคือมุมมองของ avgDists:

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

('OWNDATA' เป็นเท็จระบุว่านี่เป็นมุมมองไม่ใช่สำเนา)

อีกวิธีในการทำเช่นนี้คือ:

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

ปัญหาคือวิธีการทำงานนี้คือการสร้างลบของแต่ละองค์ประกอบในอาร์เรย์:

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

ANd สร้างสำเนาเพื่อทำ:

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

ดังนั้นหากคุณจับเวลาแต่ละครั้งด้วยชุดข้อมูลขนาดเล็กมากนี้:

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

วิธีการดูเร็วกว่ามาก (และใช้ 1/2 หน่วยความจำ ... )

คุณสามารถใช้คำสั่ง flip numpy.flipud()หรือnumpy.fliplr()เพื่อรับดัชนีเรียงลำดับจากมากไปน้อยหลังจากเรียงลำดับโดยใช้argsortคำสั่ง นั่นคือสิ่งที่ฉันมักจะทำ

แทนที่จะใช้np.argsortคุณสามารถใช้np.argpartition- หากคุณต้องการเพียงดัชนีขององค์ประกอบต่ำสุด / สูงสุด n

ไม่จำเป็นต้องเรียงลำดับอาร์เรย์ทั้งหมด แต่เพียงส่วนที่คุณต้องการ แต่โปรดทราบว่า "ลำดับในพาร์ติชันของคุณ" ไม่ได้ถูกกำหนดดังนั้นในขณะที่มันให้ดัชนีที่ถูกต้องพวกเขาอาจไม่ได้สั่งอย่างถูกต้อง:

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

คุณสามารถสร้างสำเนาของอาร์เรย์จากนั้นคูณแต่ละองค์ประกอบด้วย -1
องค์ประกอบก่อนที่ใหญ่ที่สุดจะกลายเป็นสิ่งที่เล็กที่สุด
ดัชนีขององค์ประกอบที่เล็กที่สุดในสำเนาเป็นองค์ประกอบที่ยิ่งใหญ่ที่สุดในต้นฉบับ

ด้วยตัวอย่างของคุณ:

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

รับดัชนี n ค่าสูงสุด:

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

จัดเรียงตามลำดับจากมากไปน้อย:

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

รับผลลัพธ์ (สำหรับ n = 4):

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

ตามที่ @Kanmani พูดเป็นนัย ๆ การตีความการใช้งานที่ง่ายขึ้นอาจจะใช้numpy.flipดังต่อไปนี้:

import numpy as np

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

โดยใช้รูปแบบผู้เข้าชมมากกว่าฟังก์ชั่นสมาชิกจะง่ายต่อการอ่านคำสั่งของการดำเนินงาน

อีกวิธีหนึ่งคือใช้ '-' ในอาร์กิวเมนต์สำหรับ argsort เช่นเดียวกับ: "df [np.argsort (-df [:, 0])]", หาก df เป็น dataframe และคุณต้องการเรียงลำดับตามครั้งแรก คอลัมน์ (แสดงด้วยหมายเลขคอลัมน์ '0') เปลี่ยนชื่อคอลัมน์ตามความเหมาะสม แน่นอนคอลัมน์จะต้องเป็นตัวเลข