Algoritmo per il monitoraggio dinamico dei quantili

Voglio stimare il quantile di alcuni dati. I dati sono così enormi che non possono essere inseriti nella memoria. E i dati non sono statici, i nuovi dati continuano ad arrivare. Qualcuno conosce qualche algoritmo per monitorare i quantili dei dati osservati finora con memoria e calcolo molto limitati? Trovo utile l' algoritmo P2 , ma non funziona molto bene per i miei dati, che sono distribuiti in modo estremamente pesante.

L'algoritmo P2 è una bella scoperta. Funziona facendo diverse stime del quantile, aggiornandole periodicamente e usando l' interpolazione quadratica (non lineare, non cubica) per stimare il quantile. Gli autori sostengono che l'interpolazione quadratica funziona meglio nelle code rispetto all'interpolazione lineare e che i cubi diventerebbero troppo esigenti e difficili.

Non si afferma esattamente come questo approccio fallisca per i dati "dalla coda pesante", ma è facile da indovinare: le stime dei quantili estremi per le distribuzioni dalla coda pesante saranno instabili fino a quando non verrà raccolta una grande quantità di dati. Ma questo sarà un problema (in misura minore) anche se dovessi archiviare tutti i dati, quindi non aspettarti miracoli!

Ad ogni modo, perché non impostare marcatori ausiliari - chiamiamoli e x 6 - entro i quali sei altamente sicuro che il quantile mentirà e memorizzeremo tutti i dati compresi tra x 0 e x 6 ? Quando il buffer si riempie dovrai aggiornare questi marker, mantenendo sempre x 0 ≤ x 6 . Un semplice algoritmo per fare ciò può essere ideato da una combinazione di (a) la stima P2 corrente del conteggio quantile e (b) memorizzato del numero di dati inferiore a x 0 e il numero di dati maggiore di x $x_0$$x_6$$x_0$$x_6$$x_0 \le x_6$$x_0$$x_6$. In questo modo è possibile, con elevata certezza, stimare il quantile così come se si avesse sempre l'intero set di dati sempre disponibile, ma è necessario solo un buffer relativamente piccolo.

In particolare, sto proponendo una struttura di dati per mantenere informazioni parziali su una sequenza di n valori di dati x 1 , x 2 , … , x n . Qui, y è un elenco collegato$(k, \mathbf{y}, n)$$n$$x_1, x_2, \ldots, x_n$$\mathbf{y}$

In questa notazione denota la i esimo più piccolo dei n x valori letto finora. m è una costante, la dimensione del buffer y .$x^{(n)}_{[i]}$$i^\text{th}$$n$ $x$$m$$\mathbf{y}$

L'algoritmo inizia riempiendo con i primi m valori di dati rilevati e posizionandoli in ordine ordinato, dal più piccolo al più grande. Sia q essere il quantile da stimare; ad es. q = 0,99. Dopo aver letto x n + 1 ci sono tre possibili azioni:$\mathbf{y}$$m$$q$$q$$x_{n+1}$

• Se , incrementa k .$x_{n+1} \lt x^{(n)}_{[k+1]}$$k$

• Se , non fare nulla.$x_{n+1} \gt x^{(n)}_{[k+m]}$

• Altrimenti, inserisci in y .$x_{n+1}$$\mathbf{y}$

In ogni caso, incremento .$n$

La procedura di inserimento inserisce in y in ordine ordinato e quindi elimina uno dei valori estremi in y :$x_{n+1}$$\mathbf{y}$$\mathbf{y}$

• Se , quindi rimuovere x ( n ) [ k + 1 ] da y e incrementare k ;$k + m/2 \lt n q$$x^{(n)}_{[k+1]}$$\mathbf{y}$$k$

• Altrimenti, rimuovere da y .$x^{(n)}_{[k+m]}$$\mathbf{y}$

Se è sufficientemente grande, questa procedura raggrupperà il vero quantile della distribuzione con alta probabilità. In qualsiasi fase n può essere stimato nel solito modo in termini di x ( n ) [ ⌊ q n ⌋ ] e x ( n ) [ ⌈ q n ⌉ ] , che probabilmente risiederà in y . (Credo che m debba solo ridimensionare come la radice quadrata della massima quantità di dati ( $m$$n$$x^{(n)}_{[\lfloor{q n}\rfloor]}$$x^{(n)}_{[\lceil{q n}\rceil]}$$\mathbf{y}$$m$$N$), ma non ho effettuato un'analisi rigorosa per dimostrarlo. In ogni caso, l'algoritmo rileverà se è riuscito (confrontando e ( k + m ) / n con q ).$k/n$$(k+m)/n$$q$

Test con un massimo di 100.000 valori, usando $m = 2\sqrt{N}$ and $q=.5$ (the most difficult case) indicates this algorithm has a 99.5% success rate in obtaining the correct value of $x^{(n)}_{[\lfloor{q n}\rfloor]}$. For a stream of $N=10^{12}$ values, that would require a buffer of only two million (but three or four million would be a better choice). Using a sorted doubly linked list for the buffer requires $O(\log(\sqrt{N}))$ = $O(\log(N))$ effort while identifying and deleting the max or min are $O(1)$ operations. The relatively expensive insertion typically needs to be done only $O(\sqrt{N})$ times. Thus the computational costs of this algorithm are $O(N + \sqrt{N} \log(N)) = O(N)$ in time and $O(\sqrt{N})$ in storage.

$O(\sqrt N)$ storage or it doesn't work out for some other reason, here is an idea for a different generalization of P2. It's not as detailed as what whuber suggests - more like a research idea instead of as a solution.

Instead of tracking the quantiles at $0$, $p/2$, $p$, $(1+p)/2$, and $1$, as the original P2 algorithm suggests, you could simply keep track of more quantiles (but still a constant number). It looks like the algorithm allows for that in a very straightforward manner; all you need to do is compute the correct "bucket" for incoming points, and the right way to update the quantiles (quadratically using adjacent numbers).

Say you keep track of $25$ points. You could try tracking the quantile at $0$, $p/12$, $\dotsc$, $p \cdot 11/12$, $p$, $p + (1-p)/12$, $\dotsc$, $p + 11\cdot(1-p)/12$, $1$ (picking the points equidistantly in between $0$ and $p$, and between $p$ and $1$), or even using $22$ Chebyshev nodes of the form $p/2 \cdot (1 + \cos \frac{(2 i - 1)\pi}{22})$ and $p + (1 - p)/2 \cdot (1 + \cos \frac{(2i-1)\pi}{22})$. If $p$ is close to $0$ or $1$, you could try putting fewer points on the side where there is less probability mass and more on the other side.

If you decide to pursue this, I (and possibly others on this site) would be interested in knowing if it works...

Press et al., Numerical Recipes 8.5.2 "Single-pass estimation of arbitrary quantiles" p. 435, give a c++ class IQAgent which updates a piecewise-linear approximate cdf.

This can be adapted from algorithms that determine the median of a dataset online. For more information, see this stackoverflow post - /programming/1387497/find-median-value-from-a-growing-set

I'd look at quantile regression. You can use it to determine a parametric estimate of whichever quantiles you want to look at. It make no assumption regarding normality, so it handles heteroskedasticity pretty well and can be used one a rolling window basis. It's basically an L1-Norm penalized regression, so it's not too numerically intensive and there's a pretty full featured R, SAS, and SPSS packages plus a few matlab implementations out there. Here's the main and the R package wikis for more info.

Edited:

Check out the math stack exchange crosslink: Someone sited a couple of papers that essentially lay out the very simple idea of just using a rolling window of order statistics to estimate quantiles. Literally all you have to do is sort the values from smallest to largest, select which quantile you want, and select the highest value within that quantile. You can obviously give more weight to the most recent observations if you believe they are more representative of actual current conditions. This will probably give rough estimates, but it's fairly simple to do and you don't have to go through the motions of quantitative heavy lifting. Just a thought.

It is possible to estimate (and track) quantiles on an on-line basis (the same applies to the parameters of a quantile regression). In essence, this boils down to stochastic gradient descent on the check-loss function which defines quantile-regression (quantiles being represented by a model containing only an intercept), e.g. updating the unknown parameters as and when observations arrive.

See the Bell Labs paper "Incremental Quantile Estimation for Massive Tracking" ( ftp://ftp.cse.buffalo.edu/users/azhang/disc/disc01/cd1/out/papers/kdd/p516-chen.pdf)

Another important algorithm is M. Greenwald and S. Khanna 2004 - Space-efficient online computation of quantile summaries.