Histogramme de valeurs discrètes avec matplotlib

J'ai parfois de l'histogramme des valeurs discrètes avec matplotlib. Dans ce cas, le choix de la zone de binning peut être crucial: si vous histogramme [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] à l'aide de 10 bacs, l'un des bacs de deux fois plus de compte comme les autres. En d'autres termes, la binsize devrait normalement être un multiple de la discrétisation de la taille.

Alors que ce simple cas est relativement facile à gérer par moi-même, quelqu'un aurait-il un pointeur vers une bibliothèque/fonction qui permettrait de prendre soin de cette automcatically, y compris dans le cas de données en virgule flottante où la discrétisation de la taille pourrait être légèrement différentes en raison de FP arrondi?

Grâce.

OriginalL'auteur antony | 2015-05-07

  1. 19

    Donné le titre de votre question, je vais supposer que la discrétisation de la taille est constante.

    Vous pouvez trouver cette discrétisation de la taille (ou au moins, strictement, n fois que la taille que vous ne pouvez pas avoir deux échantillons adjacents dans vos données)

    np.diff(np.unique(data)).min()

    Ce trouve les valeurs uniques de vos données (np.unique), trouve les différences entre ensuite (np.diff). Le unique est nécessaire afin que vous n'obtenez pas les valeurs nulles. Vous ensuite de trouver le minimum de différence. Il pourrait y avoir des problèmes avec ce où la discrétisation de la constante est très faible, je reviendrai.

    Prochaine vous voulez que vos valeurs dans le milieu de l'emplacement de votre problème actuel est parce que les deux 9 et 10 sont sur les bords de la dernière bin que matplotlib fournit automatiquement, de sorte que vous obtenez deux échantillons dans un bac.

    Soi - essayez ceci:

    import matplotlib.pyplot as plt
import numpy as np

data = range(11)
data = np.array(data)

d = np.diff(np.unique(data)).min()
left_of_first_bin = data.min() - float(d)/2
right_of_last_bin = data.max() + float(d)/2
plt.hist(data, np.arange(left_of_first_bin, right_of_last_bin + d, d))
plt.show()

    Cela donne:

    Histogramme de valeurs discrètes avec matplotlib

    Petit non entier de discrétisation

    Nous pouvons faire un peu plus d'un jeu de données de test par exemple

    import random 

data = []
for _ in range(1000):
    data.append(random.randint(1,100))
data = np.array(data)
nasty_d = 1.0 / 597 #Arbitrary smallish discretization
data = data * nasty_d

    Si vous exécutez ensuite qu'à travers le tableau ci-dessus et avoir un regard sur le d que le code crache, vous verrez

    >>> print(nasty_d)
0.0016750418760469012
>>> print(d)
0.00167504187605

    Si la valeur détectée de d n'est pas la "vraie" valeur de nasty_d que les données a été créé. Toutefois - avec le truc de changer les poubelles par la moitié de d pour obtenir les valeurs du milieu - il ne devrait pas sauf votre discrétisation est très très petit, de sorte que votre bas dans les limites de la précision d'un flotteur ou vous avez 1000s de bacs et de la différence entre détecté d et "réel" de discrétisation est possible de construire un tel point que l'un des bacs de "manque" le point de données. C'est quelque chose d'être conscient, mais ne sera probablement pas vous frapper.

    Un exemple de la parcelle pour le ci-dessus est

    Histogramme de valeurs discrètes avec matplotlib

    Non uniforme de discrétisation /les plus appropriés, bacs...

    Pour d'autres cas plus complexes, vous pourriez aimer regarder ce blog je l'ai trouvé. Cela ressemble à des moyens de automatiquement "apprentissage" le meilleur bin largeurs de (continu ou quasi-continu) des données, la consultation de multiples techniques standard telles que Sturges " la règle et Freedman et Diaconis règle avant de développer son propre Bayésien dynamique de la méthode de programmation.

    Si c'est votre cas d'utilisation, - la question est beaucoup plus large et ne peut pas être adapté à une réponse définitive sur Stack Overflow, bien que nous espérons que les liens de l'aide.

    Sympa, je ne savais pas que le passage par un demi-bin permettrait de résoudre la plupart des questions, j'étais inquiet au sujet (et en effet, je parlais de discrétisation uniforme, pas sur Freedman-Diaconis type de règles, qui, j'en suis conscient). Je pense que vous avez une faute de frappe dans le code quand vous dites "la valeur détectée de d n'est pas la "vraie" valeur de l'élément d", cependant.
    Merci. Bonne place sur la typo - j'ai nettoyé jusqu'à maintenant.
    beau travail, résout un vrai problème 🙂
    Note à moi-même: utile histogramme options: plt.hist(x, bins = bins, density = True, color = "green", ec = "black" où ec signifie "bord de couleur".

    OriginalL'auteur J Richard Snape

  2. 0

    Peut-être une moins-réponse complète que J Richard Snape est, mais j'ai appris récemment et que j'ai trouvé intuitive et facile.

    import numpy as np
import matplotlib.pyplot as plt

# great seed
np.random.seed(1337)

# how many times will a fair die land on the same number out of 100 trials.
data = np.random.binomial(n=100, p=1/6, size=1000)

# the trick is to set up the bins centered on the integers, i.e.
# -0.5, 0.5, 1,5, 2.5, ... up to max(data) + 1.5. Then you substract -0.5 to
# eliminate the extra bin at the end.
bins = np.arange(0, data.max() + 1.5) - 0.5

# then you plot away
fig, ax = plt.subplots()
_ = ax.hist(data, bins)
ax.set_xticks(bins + 0.5)

    Histogramme de valeurs discrètes avec matplotlib

    S'avère que près de 16/100 jette sera le même numéro!

    OriginalL'auteur Manuel Martinez