raggruppare i dati in Python con scipy / numpy

esiste un modo più efficiente per prendere una media di un array in contenitori prespecificati? ad esempio, ho una matrice di numeri e una matrice corrispondente alle posizioni di inizio e fine del cestino in quella matrice e voglio solo prendere la media in quei raccoglitori? Ho un codice che lo fa di seguito, ma mi chiedo come possa essere ridotto e migliorato. Grazie.

from scipy import *
from numpy import *

def get_bin_mean(a, b_start, b_end):
    ind_upper = nonzero(a >= b_start)[0]
    a_upper = a[ind_upper]
    a_range = a_upper[nonzero(a_upper < b_end)[0]]
    mean_val = mean(a_range)
    return mean_val


data = rand(100)
bins = linspace(0, 1, 10)
binned_data = []

n = 0
for n in range(0, len(bins)-1):
    b_start = bins[n]
    b_end = bins[n+1]
    binned_data.append(get_bin_mean(data, b_start, b_end))

print binned_data

Probabilmente è più veloce e più facile da usare numpy.digitize():

import numpy
data = numpy.random.random(100)
bins = numpy.linspace(0, 1, 10)
digitized = numpy.digitize(data, bins)
bin_means = [data[digitized == i].mean() for i in range(1, len(bins))]

Un'alternativa a questo è usare numpy.histogram():

bin_means = (numpy.histogram(data, bins, weights=data)[0] /
             numpy.histogram(data, bins)[0])

Prova tu stesso quale è più veloce ... :)

La funzione Scipy (> = 0.11) scipy.stats.binned_statistic affronta specificamente la domanda precedente.

Per lo stesso esempio delle risposte precedenti, la soluzione di Scipy sarebbe

import numpy as np
from scipy.stats import binned_statistic

data = np.random.rand(100)
bin_means = binned_statistic(data, data, bins=10, range=(0, 1))[0]

Non sono sicuro del motivo per cui questo thread è stato bloccato; ma ecco una risposta approvata per il 2014, che dovrebbe essere molto più veloce:

import numpy as np

data = np.random.rand(100)
bins = 10
slices = np.linspace(0, 100, bins+1, True).astype(np.int)
counts = np.diff(slices)

mean = np.add.reduceat(data, slices[:-1]) / counts
print mean

Il pacchetto numpy_indexed (disclaimer: sono il suo autore) contiene funzionalità per eseguire in modo efficiente operazioni di questo tipo:

import numpy_indexed as npi
print(npi.group_by(np.digitize(data, bins)).mean(data))

Questa è essenzialmente la stessa soluzione di quella che ho pubblicato in precedenza; ma ora avvolto in una bella interfaccia, con test e tutto :)

Aggiungerei, e anche per rispondere alla domanda, trova i valori medi dei bin usando histogram2d python che lo scipy ha anche una funzione appositamente progettata per calcolare una statistica binata bidimensionale per uno o più set di dati

import numpy as np
from scipy.stats import binned_statistic_2d

x = np.random.rand(100)
y = np.random.rand(100)
values = np.random.rand(100)
bin_means = binned_statistic_2d(x, y, values, bins=10).statistic

la funzione scipy.stats.binned_statistic_dd è una generalizzazione di questa funzione per dataset di dimensioni superiori

Un'altra alternativa è usare ufunc.at. Questo metodo applica sul posto un'operazione desiderata a indici specificati. Possiamo ottenere la posizione del bin per ogni datapoint utilizzando il metodo searchsorted. Quindi possiamo usare at per incrementare di 1 la posizione dell'istogramma nell'indice dato da bin_indexes, ogni volta che incontriamo un indice in bin_indexes.

np.random.seed(1)
data = np.random.random(100) * 100
bins = np.linspace(0, 100, 10)

histogram = np.zeros_like(bins)

bin_indexes = np.searchsorted(bins, data)
np.add.at(histogram, bin_indexes, 1)