Bagaimana cara saya mendapatkan indeks nilai maksimum N dalam array NumPy?

NumPy mengusulkan cara untuk mendapatkan indeks dari nilai maksimum sebuah array via np.argmax.

Saya ingin hal serupa, tetapi mengembalikan indeks dari nilai Nmaksimum.

Misalnya, jika saya memiliki array [1, 3, 2, 4, 5],, function(array, n=3)akan mengembalikan indeks [4, 3, 1]yang sesuai dengan elemen [5, 4, 3].

Yang paling sederhana yang bisa saya lakukan adalah:

In [1]: import numpy as np

In [2]: arr = np.array([1, 3, 2, 4, 5])

In [3]: arr.argsort()[-3:][::-1]
Out[3]: array([4, 3, 1])

Ini melibatkan semacam array lengkap. Saya ingin tahu apakah numpymenyediakan cara bawaan untuk melakukan semacam parsial; sejauh ini saya belum dapat menemukannya.

Jika solusi ini ternyata terlalu lambat (terutama untuk yang kecil n), mungkin perlu melihat pengkodean sesuatu di Cython .

Versi NumPy yang lebih baru (1,8 dan lebih tinggi) memiliki fungsi yang disebut argpartitionuntuk ini. Untuk mendapatkan indeks dari empat elemen terbesar, lakukan

>>> a = np.array([9, 4, 4, 3, 3, 9, 0, 4, 6, 0])
>>> a
array([9, 4, 4, 3, 3, 9, 0, 4, 6, 0])
>>> ind = np.argpartition(a, -4)[-4:]
>>> ind
array([1, 5, 8, 0])
>>> a[ind]
array([4, 9, 6, 9])

Tidak seperti argsort, fungsi ini berjalan dalam waktu linier dalam kasus terburuk, tetapi indeks yang dikembalikan tidak diurutkan, seperti yang dapat dilihat dari hasil evaluasi a[ind]. Jika Anda juga membutuhkannya, urutkan setelahnya:

>>> ind[np.argsort(a[ind])]
array([1, 8, 5, 0])

Untuk mendapatkan elemen topk dalam urutan diurutkan dengan cara ini membutuhkan waktu O ( n + k log k ).

Lebih sederhana:

idx = (-arr).argsort()[:n]

di mana n adalah jumlah nilai maksimum.

Menggunakan:

>>> import heapq
>>> import numpy
>>> a = numpy.array([1, 3, 2, 4, 5])
>>> heapq.nlargest(3, range(len(a)), a.take)
[4, 3, 1]

Untuk daftar Python biasa:

>>> a = [1, 3, 2, 4, 5]
>>> heapq.nlargest(3, range(len(a)), a.__getitem__)
[4, 3, 1]

Jika Anda menggunakan Python 2, gunakan xrangesebagai ganti range.

Sumber: heapq - Heap queue algorithm

Jika Anda kebetulan menggunakan array multidimensi maka Anda harus meratakan dan mengurai indeks:

def largest_indices(ary, n):
    """Returns the n largest indices from a numpy array."""
    flat = ary.flatten()
    indices = np.argpartition(flat, -n)[-n:]
    indices = indices[np.argsort(-flat[indices])]
    return np.unravel_index(indices, ary.shape)

Sebagai contoh:

>>> xs = np.sin(np.arange(9)).reshape((3, 3))
>>> xs
array([[ 0.        ,  0.84147098,  0.90929743],
       [ 0.14112001, -0.7568025 , -0.95892427],
       [-0.2794155 ,  0.6569866 ,  0.98935825]])
>>> largest_indices(xs, 3)
(array([2, 0, 0]), array([2, 2, 1]))
>>> xs[largest_indices(xs, 3)]
array([ 0.98935825,  0.90929743,  0.84147098])

Jika Anda tidak peduli dengan urutan elemen terbesar K-th yang dapat Anda gunakan argpartition, yang seharusnya berkinerja lebih baik daripada memilah secara lengkap argsort.

K = 4 # We want the indices of the four largest values
a = np.array([0, 8, 0, 4, 5, 8, 8, 0, 4, 2])
np.argpartition(a,-K)[-K:]
array([4, 1, 5, 6])

Kredit pergi ke pertanyaan ini .

Saya menjalankan beberapa tes dan sepertinya argpartitionmengungguli argsortukuran array dan nilai K meningkat.

Untuk array multidimensi Anda dapat menggunakan axiskata kunci untuk menerapkan partisi di sepanjang sumbu yang diharapkan.

# For a 2D array
indices = np.argpartition(arr, -N, axis=1)[:, -N:]

Dan untuk mengambil item:

x = arr.shape[0]
arr[np.repeat(np.arange(x), N), indices.ravel()].reshape(x, N)

Tetapi perhatikan bahwa ini tidak akan mengembalikan hasil yang diurutkan. Dalam hal ini Anda dapat menggunakan np.argsort()sepanjang sumbu yang dimaksud:

indices = np.argsort(arr, axis=1)[:, -N:]

# Result
x = arr.shape[0]
arr[np.repeat(np.arange(x), N), indices.ravel()].reshape(x, N)

Berikut ini sebuah contoh:

In [42]: a = np.random.randint(0, 20, (10, 10))

In [44]: a
Out[44]:
array([[ 7, 11, 12,  0,  2,  3,  4, 10,  6, 10],
       [16, 16,  4,  3, 18,  5, 10,  4, 14,  9],
       [ 2,  9, 15, 12, 18,  3, 13, 11,  5, 10],
       [14,  0,  9, 11,  1,  4,  9, 19, 18, 12],
       [ 0, 10,  5, 15,  9, 18,  5,  2, 16, 19],
       [14, 19,  3, 11, 13, 11, 13, 11,  1, 14],
       [ 7, 15, 18,  6,  5, 13,  1,  7,  9, 19],
       [11, 17, 11, 16, 14,  3, 16,  1, 12, 19],
       [ 2,  4, 14,  8,  6,  9, 14,  9,  1,  5],
       [ 1, 10, 15,  0,  1,  9, 18,  2,  2, 12]])

In [45]: np.argpartition(a, np.argmin(a, axis=0))[:, 1:] # 1 is because the first item is the minimum one.
Out[45]:
array([[4, 5, 6, 8, 0, 7, 9, 1, 2],
       [2, 7, 5, 9, 6, 8, 1, 0, 4],
       [5, 8, 1, 9, 7, 3, 6, 2, 4],
       [4, 5, 2, 6, 3, 9, 0, 8, 7],
       [7, 2, 6, 4, 1, 3, 8, 5, 9],
       [2, 3, 5, 7, 6, 4, 0, 9, 1],
       [4, 3, 0, 7, 8, 5, 1, 2, 9],
       [5, 2, 0, 8, 4, 6, 3, 1, 9],
       [0, 1, 9, 4, 3, 7, 5, 2, 6],
       [0, 4, 7, 8, 5, 1, 9, 2, 6]])

In [46]: np.argpartition(a, np.argmin(a, axis=0))[:, -3:]
Out[46]:
array([[9, 1, 2],
       [1, 0, 4],
       [6, 2, 4],
       [0, 8, 7],
       [8, 5, 9],
       [0, 9, 1],
       [1, 2, 9],
       [3, 1, 9],
       [5, 2, 6],
       [9, 2, 6]])

In [89]: a[np.repeat(np.arange(x), 3), ind.ravel()].reshape(x, 3)
Out[89]:
array([[10, 11, 12],
       [16, 16, 18],
       [13, 15, 18],
       [14, 18, 19],
       [16, 18, 19],
       [14, 14, 19],
       [15, 18, 19],
       [16, 17, 19],
       [ 9, 14, 14],
       [12, 15, 18]])

Ini akan lebih cepat daripada penyortiran penuh tergantung pada ukuran array asli Anda dan ukuran pilihan Anda:

>>> A = np.random.randint(0,10,10)
>>> A
array([5, 1, 5, 5, 2, 3, 2, 4, 1, 0])
>>> B = np.zeros(3, int)
>>> for i in xrange(3):
...     idx = np.argmax(A)
...     B[i]=idx; A[idx]=0 #something smaller than A.min()
...     
>>> B
array([0, 2, 3])

Ini, tentu saja, melibatkan pengubahan array asli Anda. Yang dapat Anda perbaiki (jika perlu) dengan membuat salinan atau mengganti kembali nilai-nilai aslinya. ... mana yang lebih murah untuk kasus penggunaan Anda.

Metode np.argpartitionhanya mengembalikan indeks terbesar k, melakukan pengurutan lokal, dan lebih cepat daripada np.argsort(melakukan pengurutan penuh) ketika array cukup besar. Tetapi indeks yang dikembalikan TIDAK dalam urutan naik / turun . Katakanlah dengan sebuah contoh:

Kita dapat melihat bahwa jika Anda menginginkan indeks top k pesanan naik yang ketat, np.argpartitiontidak akan mengembalikan apa yang Anda inginkan.

Selain melakukan pengurutan secara manual setelah np.argpartition, solusi saya adalah menggunakan PyTorch,, torch.topkalat untuk konstruksi jaringan saraf, menyediakan API mirip NumPy dengan dukungan CPU dan GPU. Ini secepat NumPy dengan MKL, dan menawarkan peningkatan GPU jika Anda membutuhkan perhitungan matriks / vektor yang besar.

Kode indeks kenaikan ascend / descend ketat adalah:

Perhatikan bahwa torch.topkmenerima tensor obor, dan mengembalikan kedua nilai k atas dan indeks k atas dalam jenis torch.Tensor. Mirip dengan np, torch.topk juga menerima argumen sumbu sehingga Anda dapat menangani array / tensor multi-dimensi.

Menggunakan:

from operator import itemgetter
from heapq import nlargest
result = nlargest(N, enumerate(your_list), itemgetter(1))

Sekarang resultdaftar akan berisi N tupel ( index, value) di mana valuedimaksimalkan.

Menggunakan:

def max_indices(arr, k):
    '''
    Returns the indices of the k first largest elements of arr
    (in descending order in values)
    '''
    assert k <= arr.size, 'k should be smaller or equal to the array size'
    arr_ = arr.astype(float)  # make a copy of arr
    max_idxs = []
    for _ in range(k):
        max_element = np.max(arr_)
        if np.isinf(max_element):
            break
        else:
            idx = np.where(arr_ == max_element)
        max_idxs.append(idx)
        arr_[idx] = -np.inf
    return max_idxs

Ini juga bekerja dengan array 2D. Sebagai contoh,

In [0]: A = np.array([[ 0.51845014,  0.72528114],
                     [ 0.88421561,  0.18798661],
                     [ 0.89832036,  0.19448609],
                     [ 0.89832036,  0.19448609]])
In [1]: max_indices(A, 8)
Out[1]:
    [(array([2, 3], dtype=int64), array([0, 0], dtype=int64)),
     (array([1], dtype=int64), array([0], dtype=int64)),
     (array([0], dtype=int64), array([1], dtype=int64)),
     (array([0], dtype=int64), array([0], dtype=int64)),
     (array([2, 3], dtype=int64), array([1, 1], dtype=int64)),
     (array([1], dtype=int64), array([1], dtype=int64))]

In [2]: A[max_indices(A, 8)[0]][0]
Out[2]: array([ 0.89832036])

bottleneck memiliki fungsi sortir parsial, jika biaya memilah seluruh array hanya untuk mendapatkan nilai N terbesar terlalu besar.

_{Saya tidak tahu apa-apa tentang modul ini; Saya baru saja googled numpy partial sort.}

Berikut ini adalah cara yang sangat mudah untuk melihat elemen maksimum dan posisinya. Ini axisdomainnya; axis= 0 berarti jumlah maksimum bijaksana kolom dan axis= 1 berarti jumlah maksimum baris bijaksana untuk kasus 2D. Dan untuk dimensi yang lebih tinggi itu tergantung pada Anda.

M = np.random.random((3, 4))
print(M)
print(M.max(axis=1), M.argmax(axis=1))

Saya menemukan ini paling intuitif untuk digunakan np.unique.

Idenya adalah, bahwa metode unik mengembalikan indeks nilai input. Kemudian dari nilai unik maks dan indeks, posisi nilai asli dapat dibuat kembali.

multi_max = [1,1,2,2,4,0,0,4]
uniques, idx = np.unique(multi_max, return_inverse=True)
print np.squeeze(np.argwhere(idx == np.argmax(uniques)))
>> [4 7]

Saya pikir cara efisiensi waktu yang paling banyak adalah secara manual beralih melalui array dan menyimpan min-heap k-size, seperti yang orang lain katakan.

Dan saya juga datang dengan pendekatan brute force:

top_k_index_list = [ ]
for i in range(k):
    top_k_index_list.append(np.argmax(my_array))
    my_array[top_k_index_list[-1]] = -float('inf')

Atur elemen terbesar ke nilai negatif besar setelah Anda menggunakan argmax untuk mendapatkan indeksnya. Dan kemudian panggilan argmax selanjutnya akan mengembalikan elemen terbesar kedua. Dan Anda dapat mencatat nilai asli dari elemen-elemen ini dan memulihkannya jika Anda mau.

Kode ini berfungsi untuk array matriks numpy:

mat = np.array([[1, 3], [2, 5]]) # numpy matrix

n = 2  # n
n_largest_mat = np.sort(mat, axis=None)[-n:] # n_largest 
tf_n_largest = np.zeros((2,2), dtype=bool) # all false matrix
for x in n_largest_mat: 
  tf_n_largest = (tf_n_largest) | (mat == x) # true-false  

n_largest_elems = mat[tf_n_largest] # true-false indexing 

Ini menghasilkan pengindeksan matriks n_largest true-false yang juga berfungsi untuk mengekstrak elemen n_largest dari array matriks