Python Seaborn: come vengono calcolate le barre di errore nei grafici a barre?

Sto usando la libreria Seaborn per generare grafici a barre in Python. Mi chiedo quali statistiche vengono utilizzate per calcolare le barre di errore, ma non riesco a trovare alcun riferimento a questo nella documentazione del grafico a barre del Seaborn .

So che i valori della barra sono calcolati in base alla media nel mio caso (l'opzione predefinita) e presumo che le barre di errore siano calcolate in base a un intervallo di confidenza del 95% nella distribuzione normale, ma vorrei esserne sicuro.

python visualization

— Michael Hooreman
fonte

Solo un commento. Ho appena iniziato a studiare Seaborn e ho la stessa domanda. Sfortunatamente non ho potuto ricavare molto dall'unica risposta per quanto riguarda quale test usare (forse è colpa mia). Ora per la tua domanda, immagino che il test dipenda da cosa è lo stimatore e da cosa sono noti in precedenza. Ad esempio si potrebbe usare un IC al 95% con un test Z per la normalità per usare la media del campione per stimare la media della popolazione, ma in questo caso la popolazione standard deve essere conosciuta in anticipo. Tuttavia, se non è noto, allora devi usare il test t, usando la distribuzione di

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

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

— Mathmath,

Osservando la fonte (seaborn / seaborn / categorical.py, linea 2166), troviamo

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

quindi il valore predefinito è, in effetti, .95, come hai indovinato.

EDIT: come viene calcolato CI: barplotchiamate utils.ci()che ha

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 questa chiamata a percentiles()sta chiamando:

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=Nonecosì score = stats.scoreatpercentile(a.ravel(), p)che è

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

Ad esempio, il punteggio per = 50 è la mediana. Se il quantile desiderato si trova tra due punti dati, interpoliamo tra loro, in base al valore dell'interpolazione. Se viene fornito il limite del parametro, dovrebbe essere una tupla (inferiore, superiore) di due valori.

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 cercando nella fonte scipy.stats.stats.py vediamo la firma

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

quindi dal momento che seaboard lo chiama senza parametri perché interpolationlo sta usando fraction.

In una nota a margine, c'è un avvertimento sulla futura obsolescenza stats.scoreatpercentile(), vale a dire

Questa funzione diventerà obsoleta in futuro. Per Numpy 1.9 e versioni successive, numpy.percentile fornisce tutte le funzionalità fornite da scoreatpercentile. Ed è significativamente più veloce. Pertanto si consiglia di utilizzare numpy.percentile per gli utenti che hanno numpy> = 1.9.

— Shawn Mehan
fonte

Sì, certo, ma la mia domanda riguarda quale test statistico viene utilizzato. Grazie

— Michael Hooreman,

La documentazione di @Shawn dice che usano il bootstrap e penso che sia vero: github.com/mwaskom/seaborn/blob/master/seaborn/…

— Direvius