Qual è un buon algoritmo per stimare la mediana di un enorme set di dati read-once?

Sto cercando un buon algoritmo (che significa calcolo minimo, requisiti minimi di archiviazione) per stimare la mediana di un set di dati che è troppo grande per essere archiviato, in modo tale che ogni valore possa essere letto una sola volta (a meno che tu non lo memorizzi esplicitamente). Non ci sono limiti ai dati che si possono assumere.

Le approssimazioni vanno bene, purché sia ​​nota la precisione.

Qualche puntatore?

Potresti raggruppare il set di dati in set di dati molto più piccoli (diciamo 100 o 1000 o 10.000 punti dati) Se poi calcolassi la mediana di ciascuno dei gruppi. Se lo facessi con abbastanza set di dati, potresti tracciare qualcosa come la media dei risultati di ciascuno dei set più piccoli e questo woul, eseguendo abbastanza set di dati più piccoli converge in una soluzione "media".

Che ne dici di una procedura di binning? Supponiamo (a scopo illustrativo) di sapere che i valori sono compresi tra 1 e 1 milione. Imposta N bin, di dimensione S. Quindi se S = 10000, avresti 100 bin, corrispondenti ai valori [1: 10000, 10001: 20000, ..., 990001: 1000000]

Quindi, scorrere i valori. Invece di memorizzare ogni valore, basta incrementare il contatore nel cestino appropriato. Utilizzando il punto medio di ciascun cestino come stima, è possibile effettuare una ragionevole approssimazione della mediana. È possibile ridimensionare la risoluzione fino a ottenere la risoluzione desiderata, modificando la dimensione dei contenitori. Sei limitato solo da quanta memoria hai.

Dal momento che non sai quanto possono essere grandi i tuoi valori, basta scegliere una dimensione del cestino abbastanza grande da non rischiare di esaurire la memoria, usando alcuni rapidi calcoli sul retro della busta. Puoi anche conservare i bin in modo sparso, in modo tale da aggiungere un cestino solo se contiene un valore.

Modificare:

Il link ryfm fornisce un esempio di ciò, con l'ulteriore passaggio di utilizzare le percentuali cumulative per stimare più accuratamente il punto all'interno del cestino mediano, anziché semplicemente usare i punti medi. Questo è un bel miglioramento.

Ti reindirizzo alla mia risposta a una domanda simile . In poche parole, è una lettura una volta, algoritmo "al volo" con complessità nel caso peggiore per calcolare la mediana (esatta).$O(n)$

L' algoritmo Rivest-Tarjan-Selection (a volte chiamato anche algoritmo mediana delle mediane) ti permetterà di calcolare l'elemento mediano in tempo lineare senza alcun ordinamento. Per set di dati di grandi dimensioni, questo può essere un po 'più veloce dell'ordinamento log-linear. Tuttavia, non risolverà il problema di archiviazione della memoria.

Ho implementato l' algoritmo P-Square per il calcolo dinamico di quantili e istogrammi senza memorizzare le osservazioni in un accurato modulo Python che ho scritto chiamato LiveStats . Dovrebbe risolvere il tuo problema in modo abbastanza efficace.

Non ho mai dovuto farlo, quindi questo è solo un suggerimento.

Vedo due (altre) possibilità.

Mezzi dati

1. Carica a metà i dati e ordina
2. Quindi leggi i valori rimanenti e confronta con l'elenco ordinato.
   1. Se il nuovo valore è più grande, scartalo.
   2. else inserisce il valore nell'elenco ordinato e rimuove il valore più grande da tale elenco.

Distribuzione campionaria

L'altra opzione è utilizzare un'approssimazione che coinvolge la distribuzione campionaria. Se i tuoi dati sono normali, l'errore standard per n moderato è:

1.253 * sd / sqrt (n)

Per determinare la dimensione di n di cui saresti felice, ho eseguito una rapida simulazione Monte-Carlo in R

n = 10000
outside.ci.uni = 0
outside.ci.nor = 0
N=1000
for(i in 1:N){
  #Theoretical median is 0
  uni = runif(n, -10, 10)
  nor  = rnorm(n, 0, 10)

  if(abs(median(uni)) > 1.96*1.253*sd(uni)/sqrt(n))
    outside.ci.uni = outside.ci.uni + 1

  if(abs(median(nor)) > 1.96*1.253*sd(nor)/sqrt(n))
    outside.ci.nor = outside.ci.nor + 1
}

outside.ci.uni/N
outside.ci.nor/N

Per n = 10000, il 15% delle stime mediane uniformi era al di fuori dell'IC.

Puoi provare a trovare una mediana basata sulla distribuzione di frequenza raggruppata, ecco alcuni dettagli

Ecco una risposta alla domanda posta su StackOverflow: https://stackoverflow.com/questions/1058813/on-line-iterator-algorithms-for-estimating-statistical-median-mode-skewness/2144754#2144754

L'aggiornamento iterativo mediana + = eta * sgn (campione - mediana) sembra che potrebbe essere una strada da percorrere.

L' algoritmo Remedian (PDF) fornisce una stima mediana a un passaggio con requisiti di archiviazione bassi e precisione ben definita.

Il rimedio con base b procede calcolando le mediane dei gruppi di osservazioni b, quindi le mediane di queste mediane, fino a quando rimane una sola stima. Questo metodo richiede semplicemente k matrici di dimensione b (dove n = b ^ k) ...

Se i valori che stai utilizzando rientrano in un determinato intervallo, ad esempio da 1 a 100000, puoi calcolare in modo efficiente la mediana su un numero estremamente elevato di valori (ad esempio, trilioni di voci), con un bucket intero (questo codice preso da EA con licenza BSD -utils / sam-stats.cpp)

class ibucket {
public:
    int tot;
    vector<int> dat;
    ibucket(int max) {dat.resize(max+1);tot=0;}
    int size() const {return tot;};

    int operator[] (int n) const {
        assert(n < size());
        int i;
        for (i=0;i<dat.size();++i) {
            if (n < dat[i]) {
                return i;
            }
            n-=dat[i];
        }
    }

    void push(int v) {
        assert(v<dat.size());
        ++dat[v];
        ++tot;
    }
};


template <class vtype>
double quantile(const vtype &vec, double p) {
        int l = vec.size();
        if (!l) return 0;
        double t = ((double)l-1)*p;
        int it = (int) t;
        int v=vec[it];
        if (t > (double)it) {
                return (v + (t-it) * (vec[it+1] - v));
        } else {
                return v;
        }
}