Qu'est-ce qu'un bon algorithme pour estimer la médiane d'un énorme jeu de données en lecture unique?

Je recherche un bon algorithme (calcul minimal, exigences de stockage minimales) pour estimer la médiane d'un ensemble de données trop volumineux pour être stocké, de telle sorte que chaque valeur ne puisse être lue qu'une fois (à moins que vous stockiez explicitement cette valeur). Aucune donnée sur les données ne peut être supposée.

Les approximations sont correctes, à condition que la précision soit connue.

Des pointeurs?

Pourriez-vous regrouper l'ensemble de données dans des ensembles de données beaucoup plus petits (par exemple, 100, 1 000 ou 10 000 points de données) si vous avez ensuite calculé la médiane de chacun des groupes. Si vous le faisiez avec suffisamment d'ensembles de données, vous pourriez tracer quelque chose comme la moyenne des résultats de chacun des ensembles les plus petits et ce, en exécutant suffisamment d'ensembles de données plus petits qui convergent vers une solution «moyenne».

Que diriez-vous de quelque chose comme une procédure de binning? Supposons (à titre d'illustration) que vous savez que les valeurs sont comprises entre 1 et 1 million. Mettre en place N bacs, de taille S. Donc, si S = 10000, vous auriez 100 bacs, correspondant aux valeurs [1: 10000, 10001: 20000, ..., 990001: 1000000]

Puis, parcourez les valeurs. Au lieu de stocker chaque valeur, incrémentez simplement le compteur dans le bac approprié. En utilisant le point médian de chaque case comme estimation, vous pouvez obtenir une approximation raisonnable de la médiane. Vous pouvez adapter cette résolution à une résolution aussi fine ou grossière que vous le souhaitez en modifiant la taille des bacs. Vous n'êtes limité que par la quantité de mémoire dont vous disposez.

Puisque vous ne savez pas quelle taille peuvent prendre vos valeurs, il vous suffit de choisir une taille de corbeille suffisamment grande pour ne pas manquer de mémoire, à l'aide de calculs rapides de retour en arrière. Vous pouvez également stocker les bacs de manière éparse, de sorte que vous n’ajoutez un bac que s’il contient une valeur.

Modifier:

Le lien ryfm en donne un exemple, avec l'étape supplémentaire consistant à utiliser les pourcentages cumulés pour estimer plus précisément le point dans la tranche médiane, au lieu d'utiliser uniquement les points centraux. C'est une belle amélioration.

$O(n)$

L' algorithme Rivest-Tarjan-Selection (parfois aussi appelé algorithme de la médiane des médianes) vous permettra de calculer l'élément médian en temps linéaire, sans aucun tri. Pour les grands ensembles de données, cela peut être un peu plus rapide que le tri log-linéaire. Cependant, cela ne résoudra pas votre problème de stockage de mémoire.

J'ai implémenté l' algorithme P-square pour le calcul dynamique de quantiles et d'histogrammes sans stockage d'observations dans un module Python soigné que j'ai écrit, appelé LiveStats . Cela devrait résoudre votre problème assez efficacement.

Je n'ai jamais eu à faire cela, alors ce n'est qu'une suggestion.

Je vois deux (autres) possibilités.

Demi-données

1. Chargez en deux les données et triez
2. Ensuite, lisez les valeurs restantes et comparez-les à la liste triée.
   1. Si la nouvelle valeur est plus grande, jetez-la.
   2. sinon mettez la valeur dans la liste triée et en supprimant la plus grande valeur de cette liste.

Distribution d'échantillonnage

L'autre option consiste à utiliser une approximation impliquant la distribution d'échantillonnage. Si vos données sont normales, l’erreur standard pour n modéré est la suivante:

1,253 * sd / sqrt (n)

Pour déterminer la taille de n qui vous conviendrait le mieux, j’ai exécuté une simulation rapide de Monte-Carlo dans 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

Pour n = 10 000, 15% des estimations de la médiane uniforme étaient en dehors de l'IC.

Vous pouvez essayer de trouver une médiane basée sur la distribution de fréquence groupée, voici quelques détails

Voici une réponse à la question posée sur stackoverflow: https://stackoverflow.com/questions/1058813/on-line-iterator-algorithms-for-estimating-statistical-median-mode-skewness/2144754#2144754

La mise à jour itérative médiane + = eta * sgn (échantillon - médiane) semble être une solution.

L' algorithme Remedian (PDF) fournit une estimation médiane en un seul passage avec de faibles exigences de stockage et une précision bien définie.

Le remède de base b procède en calculant les médianes de groupes d'observations b, puis les médianes de ces médianes, jusqu'à ce qu'il ne reste qu'une seule estimation. Cette méthode a simplement besoin de k tableaux de taille b (où n = b ^ k) ...

Si les valeurs que vous utilisez sont comprises dans une certaine plage, par exemple, entre 1 et 100 000, vous pouvez calculer efficacement la médiane sur un très grand nombre de valeurs (disons, des milliards d'entrées), avec un compartiment entier (ce code tiré d'une licence sous licence 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;
        }
}