कैसे एक numpy बहुआयामी सरणी

Question

मैं StackOverflow पर कुछ प्रश्नों के माध्यम से चला गया से कश्मीर अधिकतम मान के अनुक्रमित पाने के लिए, लेकिन प्रासंगिक जवाब नहीं मिल सका। मैं numpyndarray से अधिकतम मूल्यों के सूचकांक प्राप्त करना चाहता हूं। This link इसकी चर्चा करता है लेकिन 1 डी सरणी के लिए। 2 डी सरणी के लिए np.argsort परिणामस्वरूप पंक्तियों के अनुसार तत्वों को क्रमबद्ध करने के परिणामस्वरूप। यानी

Note: array elements are not unique. 

इनपुट:

import numpy as np 
n = np.arange(9).reshape(3,3) 
>>> n 
array([[0, 1, 2], 
    [3, 4, 5], 
    [6, 7, 8]]) 
s = n.argsort() 
>>> s 
array([[0, 1, 2], 
    [0, 1, 2], 
    [0, 1, 2]], dtype=int32) 

इसके अलावा,

import numpy as np 
n = np.arange(9).reshape(3,3) 
s = n.argsort(axis=None) 
>>>s 
array([0, 1, 2, 3, 4, 5, 6, 7, 8], dtype=int32) 

लेकिन मैं सरणी संरचना यहाँ खो रहा हूँ और तत्वों के मूल सूचकांक रिडीम नहीं कर सकते।

मदद का कोई भी KNID की सराहना की है।

Answer 1

ndarrays के लिए np.argpartition और np.argsort साथ दृष्टिकोण की युगल -

def k_largest_index_argpartition_v1(a, k): 
    idx = np.argpartition(-a.ravel(),k)[:k] 
    return np.column_stack(np.unravel_index(idx, a.shape)) 

def k_largest_index_argpartition_v2(a, k): 
    idx = np.argpartition(a.ravel(),a.size-k)[-k:] 
    return np.column_stack(np.unravel_index(idx, a.shape)) 

def k_largest_index_argsort(a, k): 
    idx = np.argsort(a.ravel())[:-k-1:-1] 
    return np.column_stack(np.unravel_index(idx, a.shape)) 

साथ k_largest_index_argpartition_v1 और k_largest_index_argpartition_v2 के बीच argpartition

अंतर दो संस्करणों पर चर्चा हम कैसे argparition का उपयोग कर रहे है। पहले संस्करण में, हम इनपुट एरे को अस्वीकार कर रहे हैं और फिर argpartition का उपयोग सबसे छोटे k सूचकांक के सूचकांक प्राप्त करने के लिए करते हैं, इस प्रकार प्रभावी रूप से सबसे बड़ा k सूचकांक प्राप्त करते हैं, जबकि दूसरे संस्करण में, हमें पहले a.size-k छोटे सूचकांक मिल रहे हैं और फिर हम हैं बचे हुए सबसे बड़े k सूचकांक का चयन करना।

साथ ही, इसके लायक यहाँ यह उल्लेख है कि argpartition साथ, हम उनकी क्रमबद्ध क्रम में सूचकांक नहीं मिल रहा है। अगर क्रमबद्ध क्रम की आवश्यकता है, तो हमें post में वर्णित अनुसार, श्रेणी सरणी में np.argpartition पर फ़ीड करने की आवश्यकता है।

नमूना रन -

1) 2 डी मामला:

In [42]: a # 2D array 
Out[42]: 
array([[38, 14, 81, 50], 
     [17, 65, 60, 24], 
     [64, 73, 25, 95]]) 

In [43]: k_largest_index_argsort(a, k=2) 
Out[43]: 
array([[2, 3], 
     [0, 2]]) 

In [44]: k_largest_index_argsort(a, k=4) 
Out[44]: 
array([[2, 3], 
     [0, 2], 
     [2, 1], 
     [1, 1]]) 

In [66]: k_largest_index_argpartition_v1(a, k=4) 
Out[66]: 
array([[2, 1], # Notice the order is different 
     [2, 3], 
     [0, 2], 
     [1, 1]]) 

2) 3 डी मामला:

In [46]: a # 3D array 
Out[46]: 
array([[[20, 98, 27, 73], 
     [33, 78, 48, 59], 
     [28, 91, 64, 70]], 

     [[47, 34, 51, 19], 
     [73, 38, 63, 94], 
     [95, 25, 93, 64]]]) 

In [47]: k_largest_index_argsort(a, k=2) 
Out[47]: 
array([[0, 0, 1], 
     [1, 2, 0]]) 

रनटाइम परीक्षण -

In [56]: a = np.random.randint(0,99999999999999,(3000,4000)) 

In [57]: %timeit k_largest_index_argsort(a, k=10) 
1 loops, best of 3: 2.18 s per loop 

In [58]: %timeit k_largest_index_argpartition_v1(a, k=10) 
10 loops, best of 3: 178 ms per loop 

In [59]: %timeit k_largest_index_argpartition_v2(a, k=10) 
10 loops, best of 3: 128 ms per loop