Wie findet man die häufigsten Werte in numpy ndarray?

Question

Ich habe ein numpy ndarray mit der Form von (30.480.640), die 1. und 2. Achse, die Positionen (Breite und Länge) darstellt, die 0. Achse enthält tatsächliche Datenpunkte. Ich möchte den häufigsten Wert entlang der 0. Achse an jedem Ort verwenden , das ein neues Array mit Form von (1.480.640) .ie zu konstruieren:

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

Die Datenpunkte negtive und positive Schwimm Zahlen enthält. Wie kann ich solche Berechnungen durchführen? Danke vielmals!

Ich versuchte mit numpy.unique, aber ich bekam "TypeError: unique() hat ein unerwartetes Schlüsselwortargument 'return_inverse'". Ich benutze numpy Version 1.2.1 unter Unix installiert und es unterstützt nicht return_inverse. .Ich habe auch versucht, Modus, aber es dauert ewig, um so große Datenmengen zu verarbeiten ... gibt es also eine alternative Möglichkeit, die häufigsten Werte zu erhalten? Danke noch einmal.

Answer 1

zu den häufigsten Wert einer flachen Anordnung finden, verwenden unique, bincount und 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))] 

mit einem mehrdimensionalen Array umgehen, müssen wir über unique keine Sorge, aber wir brauchen verwenden apply_along_axis auf 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)] 

mit Ihren Daten:

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, wirklich? Sie np.unique(return_inverse=True) nähern vernünftigerweise effizient np.searchsorted (es ist ein zusätzlicher O (n log n), so sollte die Leistung nicht wesentlich verändern) mit:

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

Answer 2

flatten Ihr Array, dann bauen Sie eine collections.Counter daraus. Wie immer sollten Sie beim Vergleichen von Fließkommazahlen besondere Vorsicht walten lassen.

Answer 3

Verwenden SciPy der Modus-Funktion:

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)