Python Seaborn: como as barras de erro são computadas nos gráficos de barras?

Estou usando a biblioteca marítima para gerar gráficos de barras em python. Gostaria de saber quais estatísticas são usadas para calcular as barras de erro, mas não consigo encontrar nenhuma referência a isso na documentação do gráfico de barras do seaborn .

Sei que os valores das barras são calculados com base na média no meu caso (a opção padrão) e presumo que as barras de erro sejam calculadas com base em um intervalo de confiança de 95% da distribuição Normal, mas gostaria de ter certeza.

Observando a fonte (seaborn / seaborn / categorical.py, linha 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):

portanto, o valor padrão é, de fato, 0,95, como você adivinhou.

EDIT: Como o IC é calculado: barplotchamadas utils.ci()com

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)

e esta chamada para percentiles()está chamando:

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=Noneentão score = stats.scoreatpercentile(a.ravel(), p)qual é

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

Por exemplo, a pontuação em per = 50 é a mediana. Se o quantil desejado estiver entre dois pontos de dados, interpolamos entre eles, de acordo com o valor da interpolação. Se o limite do parâmetro for fornecido, deve ser uma tupla (inferior, superior) de dois 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).

e procurando na fonte scipy.stats.stats.py , vemos a assinatura

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

então, como a seaboard chama sem parâmetro interpolation, está sendo usada fraction.

Em uma nota lateral, há um aviso de obsolescência futura stats.scoreatpercentile(), nomeadamente

Esta função ficará obsoleta no futuro. Para o Numpy 1.9 e superior, o numpy.percentile fornece toda a funcionalidade fornecida pelo scoreatpercentile. E é significativamente mais rápido. Portanto, é recomendável usar numpy.percentile para usuários com numpy> = 1.9.