Python Seaborn: ¿cómo se calculan las barras de error en los gráficos de barras?

Estoy usando la biblioteca seaborn para generar gráficos de barras en python. Me pregunto qué estadísticas se utilizan para calcular las barras de error, pero no puedo encontrar ninguna referencia a esto en la documentación del diagrama de barras de Seaborn .

Sé que los valores de la barra se calculan en función de la media en mi caso (la opción predeterminada), y supongo que las barras de error se calculan en función de un intervalo de confianza del 95% de distribución normal, pero me gustaría estar seguro.

Mirando la fuente (seaborn / seaborn / categorical.py, línea 2166), encontramos

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):

entonces el valor predeterminado es, de hecho, .95, como lo adivinó.

EDITAR: cómo se calcula CI: barplotllamadas utils.ci()que tiene

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)

y esta llamada a percentiles()está llamando:

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=Noneentonces score = stats.scoreatpercentile(a.ravel(), p)cual es

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

Por ejemplo, la puntuación en per = 50 es la mediana. Si el cuantil deseado se encuentra entre dos puntos de datos, interpolamos entre ellos, de acuerdo con el valor de la interpolación. Si se proporciona el límite del parámetro, debe ser una tupla (inferior, superior) de dos valores.

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).

y buscando en la fuente scipy.stats.stats.py vemos la firma

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

así que desde seaboard lo llama sin param porque interpolationlo está usando fraction.

En una nota al margen, hay una advertencia de futura obsolescencia en stats.scoreatpercentile(), a saber

Esta función quedará obsoleta en el futuro. Para Numpy 1.9 y superior, numpy.percentile proporciona toda la funcionalidad que ofrece el gran perfil. Y es significativamente más rápido. Por lo tanto, se recomienda usar numpy.percentile para usuarios que tienen numpy> = 1.9.