Python Seaborn: comment les barres d'erreur sont-elles calculées dans les graphiques à barres?

J'utilise la bibliothèque seaborn pour générer des graphiques à barres en python. Je me demande quelles statistiques sont utilisées pour calculer les barres d'erreur, mais je ne trouve aucune référence à cela dans la documentation de barplot du seaborn .

Je sais que les valeurs des barres sont calculées en fonction de la moyenne dans mon cas (l'option par défaut), et je suppose que les barres d'erreur sont calculées en fonction d'un intervalle de confiance à 95% de la distribution normale, mais j'aimerais en être sûr.

python visualization

— Michael Hooreman
source

Juste un commentaire. Je viens de commencer à apprendre Seaborn et à poser la même question. Malheureusement, je n'ai pas pu tirer grand-chose de la seule réponse en ce qui concerne le test à utiliser (c'est peut-être ma faute). Maintenant, pour votre question, je suppose que le test dépend de ce qu'est l'estimateur et de ce que l'on sait à l'avance. Par exemple, on pourrait utiliser un IC à 95% avec un test Z pour la normalité afin d'utiliser la moyenne de l'échantillon pour estimer la moyenne de la population, mais dans ce cas, le std de la population doit être connu à l'avance. Cependant, si ce n'est pas connu, vous devez utiliser le test t, en utilisant la distribution de

t := \frac{\bar{x} - μ}{s / \sqrt{(} n - 1)}

$t:=\frac{\bar{x}-\mu}{s/\sqrt(n-1)}$ .

— Mathmath

En regardant la source (seaborn / seaborn / categorical.py, ligne 2166), on trouve

def barplot(x=None, y=None, hue=None, data=None, order=None, hue_order=None,
        estimator=np.mean, ci=95, n_boot=1000, units=None,
        orient=None, color=None, palette=None, saturation=.75,
        errcolor=".26", ax=None, **kwargs):

donc la valeur par défaut est, en effet, .95, comme vous l'avez deviné.

EDIT: Comment le CI est calculé: les barplotappels utils.ci()qui ont

seaborn / seaborn / utils.py

def ci(a, which=95, axis=None):
    """Return a percentile range from an array of values."""
    p = 50 - which / 2, 50 + which / 2
    return percentiles(a, p, axis)

et cet appel à percentiles()appelle:

def percentiles(a, pcts, axis=None):
    """Like scoreatpercentile but can take and return array of percentiles.
    Parameters
    ----------
    a : array
        data
    pcts : sequence of percentile values
        percentile or percentiles to find score at
    axis : int or None
        if not None, computes scores over this axis
    Returns
    -------
    scores: array
        array of scores at requested percentiles
        first dimension is length of object passed to ``pcts``
    """
    scores = []
    try:
        n = len(pcts)
    except TypeError:
        pcts = [pcts]
        n = 0
    for i, p in enumerate(pcts):
        if axis is None:
            score = stats.scoreatpercentile(a.ravel(), p)
        else:
            score = np.apply_along_axis(stats.scoreatpercentile, axis, a, p)
        scores.append(score)
    scores = np.asarray(scores)
    if not n:
        scores = scores.squeeze()
    return scores

axis=Nonealors score = stats.scoreatpercentile(a.ravel(), p)qui est

scipy.stats.scoreatpercentile(a, per, limit=(), interpolation_method='fraction', axis=None)[source]
Calculate the score at a given percentile of the input sequence.

Par exemple, le score à per = 50 est la médiane. Si le quantile souhaité se situe entre deux points de données, nous interpolons entre eux, en fonction de la valeur d'interpolation. Si la limite de paramètre est fournie, il doit s'agir d'un tuple (inférieur, supérieur) de deux valeurs.

Parameters: 
a : array_like
A 1-D array of values from which to extract score.
per : array_like
Percentile(s) at which to extract score. Values should be in range [0,100].
limit : tuple, optional
Tuple of two scalars, the lower and upper limits within which to compute the percentile. Values of a outside this (closed) interval will be ignored.
interpolation_method : {‘fraction’, ‘lower’, ‘higher’}, optional
This optional parameter specifies the interpolation method to use, when the desired quantile lies between two data points i and j
fraction: i + (j - i) * fraction where fraction is the fractional part of the index surrounded by i and j.
lower: i.
higher: j.
axis : int, optional
Axis along which the percentiles are computed. Default is None. If None, compute over the whole array a.
Returns:    
score : float or ndarray
Score at percentile(s).

et en regardant dans la source pour scipy.stats.stats.py nous voyons la signature

def scoreatpercentile(a, per, limit=(), interpolation_method='fraction',
                      axis=None):

donc depuis le bord de mer l'appelle sans paramètre car interpolationil l'utilise fraction.

Soit dit en passant, il y a un avertissement d'une obsolescence future stats.scoreatpercentile(), à savoir

Cette fonction deviendra obsolète à l'avenir. Pour Numpy 1.9 et supérieur, numpy.percentile fournit toutes les fonctionnalités fournies par scoreatpercentile. Et c'est beaucoup plus rapide. Par conséquent, il est recommandé d'utiliser numpy.percentile pour les utilisateurs qui ont numpy> = 1.9.

— Shawn Mehan
source

Oui, en effet, mais ma question est de savoir quel test statistique est utilisé. Merci

— Michael Hooreman

La documentation @Shawn dit qu'ils utilisent le bootstrap et je pense que c'est vrai: github.com/mwaskom/seaborn/blob/master/seaborn/…

— Direvius