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.

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.