numpy ndarray में सबसे अधिक लगातार मूल्यों को कैसे ढूंढें?

Question

मेरे पास आकार (30,480,640) के आकार के साथ एक numpy ndarray है, 1 वें और 2 वें धुरी स्थानों (अक्षांश और लम्बाई) का प्रतिनिधित्व करते हैं, 0 वें धुरी में वास्तविक डेटा बिंदु होते हैं। मैं प्रत्येक स्थान पर 0 वें धुरी के साथ सबसे अधिक लगातार मूल्य का उपयोग करना चाहता हूं

>>> data 
array([[[ 0, 1, 2, 3, 4], 
     [ 5, 6, 7, 8, 9], 
     [10, 11, 12, 13, 14], 
     [15, 16, 17, 18, 19]], 

     [[ 0, 1, 2, 3, 4], 
     [ 5, 6, 7, 8, 9], 
     [10, 11, 12, 13, 14], 
     [15, 16, 17, 18, 19]], 

     [[40, 40, 42, 43, 44], 
     [45, 46, 47, 48, 49], 
     [50, 51, 52, 53, 54], 
     [55, 56, 57, 58, 59]]]) 

(perform calculation) 

>>> new_data 
array([[[ 0, 1, 2, 3, 4], 
     [ 5, 6, 7, 8, 9], 
     [10, 11, 12, 13, 14], 
     [15, 16, 17, 18, 19]]]) 

डेटा बिंदुओं negtive और सकारात्मक चल संख्या में शामिल होंगे: है, जो (1,480,640) .ie के आकार के साथ एक नई सरणी के निर्माण के लिए है। मैं ऐसी गणना कैसे कर सकता हूं? आपका बहुत बहुत धन्यवाद!

मैंने numpy.unique के साथ प्रयास किया, लेकिन मुझे "TypeError: unique() को एक अप्रत्याशित कीवर्ड तर्क 'return_inverse' मिला।" मैं यूनिक्स पर स्थापित numpy संस्करण 1.2.1 का उपयोग कर रहा हूं और यह return_inverse का समर्थन नहीं करता है। मैंने मोड की भी कोशिश की, लेकिन यह इतनी बड़ी मात्रा में डेटा संसाधित करने के लिए हमेशा के लिए लेता है ... तो क्या सबसे अधिक मूल्य प्राप्त करने का कोई वैकल्पिक तरीका है? एक बार फिर धन्यवाद।

Answer 1

एक फ्लैट सरणी के सबसे लगातार मूल्य मिल जाए, का उपयोग unique, bincount और argmax करने के लिए:

arr = np.array([5, 4, -2, 1, -2, 0, 4, 4, -6, -1]) 
u, indices = np.unique(arr, return_inverse=True) 
u[np.argmax(np.bincount(indices))] 

एक बहुआयामी सरणी के साथ काम करने के लिए, हम की जरूरत नहीं है के बारे में चिंता करने की unique, लेकिन हम क्या ज़रूरत है bincount पर apply_along_axis उपयोग करने के लिए:

arr = np.array([[5, 4, -2, 1, -2, 0, 4, 4, -6, -1], 
       [0, 1, 2, 2, 3, 4, 5, 6, 7, 8]]) 
axis = 1 
u, indices = np.unique(arr, return_inverse=True) 
u[np.argmax(np.apply_along_axis(np.bincount, axis, indices.reshape(arr.shape), 
           None, np.max(indices) + 1), axis=axis)] 

अपने डेटा के साथ:

data = np.array([ 
    [[ 0, 1, 2, 3, 4], 
    [ 5, 6, 7, 8, 9], 
    [10, 11, 12, 13, 14], 
    [15, 16, 17, 18, 19]], 

    [[ 0, 1, 2, 3, 4], 
    [ 5, 6, 7, 8, 9], 
    [10, 11, 12, 13, 14], 
    [15, 16, 17, 18, 19]], 

    [[40, 40, 42, 43, 44], 
    [45, 46, 47, 48, 49], 
    [50, 51, 52, 53, 54], 
    [55, 56, 57, 58, 59]]]) 
axis = 0 
u, indices = np.unique(arr, return_inverse=True) 
u[np.argmax(np.apply_along_axis(np.bincount, axis, indices.reshape(arr.shape), 
           None, np.max(indices) + 1), axis=axis)] 
array([[ 0, 1, 2, 3, 4], 
     [ 5, 6, 7, 8, 9], 
     [10, 11, 12, 13, 14], 
     [15, 16, 17, 18, 19]]) 

---

NumPy 1.2, वास्तव में? आप यथोचित कुशलतापूर्वक np.searchsorted का उपयोग कर np.unique(return_inverse=True) अनुमान लगा सकता है (यह एक अतिरिक्त ओ (n लॉग n) है, तो प्रदर्शन में काफी परिवर्तन नहीं होना चाहिए):

u = np.unique(arr) 
indices = np.searchsorted(u, arr.flat) 

Answer 2

flatten अपनी सरणी, फिर से collections.Counter बनाएं। सामान्य रूप से, फ़्लोटिंग-पॉइंट संख्याओं की तुलना करते समय विशेष देखभाल करें।

Answer 3

उपयोग SciPy के मोड समारोह:

import numpy as np 
from scipy.stats import mode 

data = np.array([[[ 0, 1, 2, 3, 4], 
        [ 5, 6, 7, 8, 9], 
        [10, 11, 12, 13, 14], 
        [15, 16, 17, 18, 19]], 

       [[ 0, 1, 2, 3, 4], 
        [ 5, 6, 7, 8, 9], 
        [10, 11, 12, 13, 14], 
        [15, 16, 17, 18, 19]], 

       [[40, 40, 42, 43, 44], 
        [45, 46, 47, 48, 49], 
        [50, 51, 52, 53, 54], 
        [55, 56, 57, 58, 59]]]) 

print data 

# find mode along the zero-th axis; the return value is a tuple of the 
# modes and their counts. 
print mode(data, axis=0)