Come trovare i valori più frequenti in numpy ndarray?

Question

Ho un ndarray numpy con la forma di (30.480.640), il 1 ° e il 2 ° asse che rappresentano le posizioni (latitudine e longitute), l'asse 0 contiene i punti dati effettivi.Voglio utilizzare il valore più frequente lungo l'asse 0 in ogni posizione , che è la costruzione di una nuova matrice a forma di (1.480.640) .ie:

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

I punti di dati conterranno numeri galleggianti negtive e positivi. Come posso eseguire tali calcoli? Molte grazie!

Ho provato con numpy.unique, ma ho ottenuto "TypeError: unique() ha ottenuto un argomento di parole chiave inaspettate 'return_inverse'". Sto usando numpy versione 1.2.1 installata su Unix e non supporta return_inverse. . Ho anche provato la modalità, ma ci vuole un istante per elaborare una quantità così grande di dati ... quindi c'è un modo alternativo per ottenere i valori più frequenti? Grazie ancora.

Answer 1

per trovare il valore più frequente di una matrice piatta, utilizzare unique, bincount e 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))] 

Per lavorare con un array multidimensionale, non abbiamo bisogno di preoccuparsi di unique, ma abbiamo bisogno di utilizzare apply_along_axis su bincount:

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

con i tuoi dati:

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, davvero? È possibile approssimare np.unique(return_inverse=True) ragionevolmente efficiente utilizzando np.searchsorted (si tratta di un O aggiuntivo (n registro n), quindi non dovrebbe cambiare le prestazioni in modo significativo):

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

Answer 2

flatten l'array, quindi creare un collections.Counter da esso. Come al solito, fare particolare attenzione quando si confrontano i numeri in virgola mobile.

Answer 3

funzione della modalità Usa 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)